@workos/oagen-emitters 0.9.1 → 0.11.0

package/dist/{plugin-Dh9JSScr.mjs → plugin-DW3cnedr.mjs}

@@ -3245,7 +3245,7 @@ function computeNonEventReachable(services, models) {
 //#region src/node/enums.ts
 function generateEnums$6(enums, ctx) {
 	if (enums.length === 0) return [];
-	const enumToService = assignEnumsToServices$1(enums, ctx.spec.services);
+	const enumToService = assignEnumsToServices(enums, ctx.spec.services);
 	const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
 	const resolveDir = (irService) => irService ? resolveServiceDir$1(serviceNameMap.get(irService) ?? irService) : "common";
 	const files = [];
@@ -3315,7 +3315,7 @@ function extractLiteralUnionValues(aliasValue) {
 	while ((match = regex.exec(aliasValue)) !== null) values.add(match[1]);
 	return values;
 }
-function assignEnumsToServices$1(enums, services) {
+function assignEnumsToServices(enums, services) {
 	const enumToService = /* @__PURE__ */ new Map();
 	const enumNames = new Set(enums.map((e) => e.name));
 	for (const service of services) for (const op of service.operations) {
@@ -3855,7 +3855,7 @@ function generateModels$6(models, ctx, shared) {
 		const typeDecls = /* @__PURE__ */ new Map();
 		const crossServiceImports = /* @__PURE__ */ new Map();
 		const unresolvableNames = /* @__PURE__ */ new Set();
-		const enumToService = assignEnumsToServices$1(ctx.spec.enums, ctx.spec.services);
+		const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
 		const resolvedEnumNames = /* @__PURE__ */ new Map();
 		for (const e of ctx.spec.enums) resolvedEnumNames.set(resolveInterfaceName(e.name, ctx), e.name);
 		for (const field of model.fields) {
@@ -4960,7 +4960,7 @@ function generateResourceClass(service, ctx) {
 	for (const [relPath, specifiers] of serializerImportsByPath) lines.push(`import { ${specifiers.join(", ")} } from '${relPath}';`);
 	const specEnumNames = new Set(ctx.spec.enums.map((e) => e.name));
 	if (paramEnums.size > 0) {
-		const enumToService = assignEnumsToServices$1(ctx.spec.enums, ctx.spec.services);
+		const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
 		for (const name of paramEnums) {
 			if (allModels.has(name)) continue;
 			if (!specEnumNames.has(name)) continue;
@@ -6924,6 +6924,330 @@ function joinUnionVariants$4(ref, variants) {
 	return `Union[${unique.join(", ")}]`;
 }
 //#endregion
+//#region src/python/shared-schemas.ts
+/**
+* Walk every operation across all services and tally, per schema, the set of
+* services that transitively reference it. Schemas referenced by more than one
+* service are "shared" — they should be emitted under common/ rather than
+* the first alphabetical service that happens to use them.
+*
+* Transitive walk for models follows model->model field references AND
+* discriminator variant mappings to a fixed point; enums are leaves.
+*/
+function findSharedSchemas(spec) {
+	const modelsByName = new Map(spec.models.map((m) => [m.name, m]));
+	const modelToServices = /* @__PURE__ */ new Map();
+	const enumToServices = /* @__PURE__ */ new Map();
+	const note = (map, name, service) => {
+		let bucket = map.get(name);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Set();
+			map.set(name, bucket);
+		}
+		bucket.add(service);
+	};
+	for (const service of spec.services) {
+		const directModels = /* @__PURE__ */ new Set();
+		const directEnums = /* @__PURE__ */ new Set();
+		const collect = (ref) => {
+			walkTypeRef(ref, {
+				model: (r) => directModels.add(r.name),
+				enum: (r) => directEnums.add(r.name)
+			});
+		};
+		for (const op of service.operations) {
+			if (op.requestBody) collect(op.requestBody);
+			collect(op.response);
+			for (const p of [
+				...op.pathParams,
+				...op.queryParams,
+				...op.headerParams,
+				...op.cookieParams ?? []
+			]) collect(p.type);
+			if (op.pagination) collect(op.pagination.itemType);
+			for (const err of op.errors) if (err.type) collect(err.type);
+			for (const sr of op.successResponses ?? []) collect(sr.type);
+		}
+		const queue = [...directModels];
+		while (queue.length > 0) {
+			const name = queue.pop();
+			const model = modelsByName.get(name);
+			if (!model) continue;
+			for (const field of model.fields) walkTypeRef(field.type, {
+				model: (r) => {
+					if (!directModels.has(r.name)) {
+						directModels.add(r.name);
+						queue.push(r.name);
+					}
+				},
+				enum: (r) => directEnums.add(r.name)
+			});
+			const disc = model.discriminator;
+			if (disc?.mapping) {
+				for (const variantName of Object.values(disc.mapping)) if (!directModels.has(variantName)) {
+					directModels.add(variantName);
+					queue.push(variantName);
+				}
+			}
+		}
+		for (const name of directModels) note(modelToServices, name, service.name);
+		for (const name of directEnums) note(enumToServices, name, service.name);
+	}
+	const sharedModels = /* @__PURE__ */ new Set();
+	for (const [name, services] of modelToServices) if (services.size >= 2) sharedModels.add(name);
+	const sharedEnums = /* @__PURE__ */ new Set();
+	for (const [name, services] of enumToServices) if (services.size >= 2) sharedEnums.add(name);
+	return {
+		models: sharedModels,
+		enums: sharedEnums
+	};
+}
+function computeSchemaPlacement(spec, ctx) {
+	const annotatedModels = detectDiscriminators(spec.models);
+	if (annotatedModels !== spec.models) spec = {
+		...spec,
+		models: annotatedModels
+	};
+	const modelsByName = new Map(spec.models.map((m) => [m.name, m]));
+	const hintedModels = new Set(Object.keys(ctx.modelHints ?? {}));
+	const originalModelToService = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
+	const originalEnumToService = assignEnumsToServicesNatural(spec.enums, spec.services);
+	const modelAliases = computeModelAliases(spec);
+	const enumAliases = computeEnumAliases(spec.enums);
+	const initial = findSharedSchemas(spec);
+	for (const [aliasName, canonicalName] of modelAliases) if (initial.models.has(aliasName)) initial.models.add(canonicalName);
+	for (const [aliasName, canonicalName] of enumAliases) if (initial.enums.has(aliasName)) initial.enums.add(canonicalName);
+	const sharedModels = /* @__PURE__ */ new Set();
+	for (const name of initial.models) if (!hintedModels.has(name)) sharedModels.add(name);
+	for (const model of spec.models) if (!originalModelToService.has(model.name) && !hintedModels.has(model.name)) sharedModels.add(model.name);
+	const sharedEnums = new Set(initial.enums);
+	for (const enumDef of spec.enums) if (!originalEnumToService.has(enumDef.name)) sharedEnums.add(enumDef.name);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const name of sharedModels) {
+			const model = modelsByName.get(name);
+			if (!model) continue;
+			const deps = collectEmittedDependencies(model, modelAliases);
+			for (const dep of deps.models) {
+				if (sharedModels.has(dep)) continue;
+				if (!modelsByName.has(dep)) continue;
+				sharedModels.add(dep);
+				changed = true;
+			}
+			for (const dep of deps.enums) {
+				if (sharedEnums.has(dep)) continue;
+				sharedEnums.add(dep);
+				changed = true;
+			}
+		}
+	}
+	const modelToService = new Map(originalModelToService);
+	for (const name of sharedModels) modelToService.delete(name);
+	const enumToService = new Map(originalEnumToService);
+	for (const name of sharedEnums) enumToService.delete(name);
+	const relocatedModels = /* @__PURE__ */ new Set();
+	for (const name of sharedModels) {
+		if (!originalModelToService.has(name)) continue;
+		relocatedModels.add(name);
+	}
+	const relocatedEnums = /* @__PURE__ */ new Set();
+	for (const name of sharedEnums) {
+		if (!originalEnumToService.has(name)) continue;
+		relocatedEnums.add(name);
+	}
+	return {
+		modelToService,
+		enumToService,
+		originalModelToService,
+		originalEnumToService,
+		relocatedModels,
+		relocatedEnums,
+		modelAliases,
+		enumAliases
+	};
+}
+/**
+* Dependencies the emitter will materialize for a model's generated file.
+* Captures alias canonicals, discriminator variants, and field-level model+enum
+* references so the placement closure can decide whether the dependency must
+* also live in `common/`.
+*/
+function collectEmittedDependencies(model, modelAliases) {
+	const models = /* @__PURE__ */ new Set();
+	const enums = /* @__PURE__ */ new Set();
+	const canonical = modelAliases.get(model.name);
+	if (canonical) {
+		models.add(canonical);
+		return {
+			models,
+			enums
+		};
+	}
+	const disc = model.discriminator;
+	if (disc?.mapping) for (const variant of Object.values(disc.mapping)) models.add(variant);
+	const fieldDeps = collectFieldDependencies(model);
+	for (const m of fieldDeps.models) models.add(m);
+	for (const e of fieldDeps.enums) enums.add(e);
+	return {
+		models,
+		enums
+	};
+}
+function collectModelUsage(spec) {
+	const request = /* @__PURE__ */ new Set();
+	const response = /* @__PURE__ */ new Set();
+	for (const service of spec.services) for (const op of service.operations) {
+		const plan = planOperation(op);
+		if (plan.responseModelName) response.add(plan.responseModelName);
+		if (op.pagination?.itemType.kind === "model") response.add(op.pagination.itemType.name);
+		if (op.requestBody?.kind === "model") request.add(op.requestBody.name);
+		if (op.requestBody?.kind === "union") {
+			for (const variant of op.requestBody.variants ?? []) if (variant.kind === "model") request.add(variant.name);
+		}
+	}
+	const mixed = /* @__PURE__ */ new Set();
+	for (const name of request) if (response.has(name)) mixed.add(name);
+	return {
+		requestOnly: new Set([...request].filter((name) => !mixed.has(name))),
+		response: new Set([...response].filter((name) => !mixed.has(name))),
+		mixed
+	};
+}
+function compareAliasPriority(left, right, usage) {
+	const score = (name) => {
+		if (usage.response.has(name)) return 0;
+		if (usage.mixed.has(name)) return 1;
+		if (usage.requestOnly.has(name)) return 2;
+		return 3;
+	};
+	const diff = score(left) - score(right);
+	if (diff !== 0) return diff;
+	return left.localeCompare(right);
+}
+function canAliasModels(canonical, alias, usage) {
+	if (fileName$2(canonical) === fileName$2(alias)) return false;
+	if (usage.response.has(canonical) && usage.requestOnly.has(alias) || usage.response.has(alias) && usage.requestOnly.has(canonical)) return false;
+	return true;
+}
+/**
+* Compute the Python emitter's structural model dedup map: alias -> canonical.
+* Mirrors the logic in models.ts so the placement closure can promote
+* canonicals when their aliases are shared.
+*/
+function computeModelAliases(spec) {
+	const recursiveHashes = buildRecursiveHashMap$1(spec.models, spec.enums);
+	const usage = collectModelUsage(spec);
+	const hashGroups = /* @__PURE__ */ new Map();
+	for (const model of spec.models) {
+		if (model.fields.length === 0 && !model.discriminator) {}
+		const hash = recursiveHashes.get(model.name) ?? "";
+		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+		hashGroups.get(hash).push(model.name);
+	}
+	const aliasOf = /* @__PURE__ */ new Map();
+	for (const [, names] of hashGroups) {
+		if (names.length <= 1) continue;
+		const sorted = [...names].sort((a, b) => compareAliasPriority(a, b, usage));
+		const canonical = sorted[0];
+		for (let i = 1; i < sorted.length; i++) if (canAliasModels(canonical, sorted[i], usage)) aliasOf.set(sorted[i], canonical);
+	}
+	return aliasOf;
+}
+/**
+* Compute the Python emitter's structural enum dedup map: alias -> canonical.
+* Mirrors the logic in enums.ts.
+*/
+function computeEnumAliases(enums) {
+	const hashGroups = /* @__PURE__ */ new Map();
+	for (const enumDef of enums) {
+		const hash = [...enumDef.values].map((v) => String(v.value)).sort().join("|");
+		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+		hashGroups.get(hash).push(enumDef.name);
+	}
+	const aliasOf = /* @__PURE__ */ new Map();
+	for (const [, names] of hashGroups) {
+		if (names.length <= 1) continue;
+		const sorted = [...names].sort();
+		const canonical = sorted[0];
+		for (let i = 1; i < sorted.length; i++) aliasOf.set(sorted[i], canonical);
+	}
+	return aliasOf;
+}
+/**
+* Recursive structural hashing for models so dedup runs against deeply-equal
+* shapes, not just same-named ones. Cycles fall back to the model name.
+*/
+function buildRecursiveHashMap$1(models, enums) {
+	const modelByName = new Map(models.map((m) => [m.name, m]));
+	const hashCache = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const enumVH = /* @__PURE__ */ new Map();
+	for (const e of enums) enumVH.set(e.name, [...e.values].map((v) => String(v.value)).sort().join("|"));
+	function modelHash(name) {
+		const cached = hashCache.get(name);
+		if (cached != null) return cached;
+		if (visiting.has(name)) return `m:${name}`;
+		visiting.add(name);
+		const model = modelByName.get(name);
+		if (!model) {
+			visiting.delete(name);
+			return `m:${name}`;
+		}
+		const hash = [...model.fields].sort((a, b) => a.name.localeCompare(b.name)).map((f) => `${f.name}:${deepTypeHash(f.type)}:${f.required}`).join("|");
+		visiting.delete(name);
+		hashCache.set(name, hash);
+		return hash;
+	}
+	function deepTypeHash(ref) {
+		switch (ref.kind) {
+			case "primitive": return `p:${ref.type}${ref.format ? `:${ref.format}` : ""}`;
+			case "model": return `m:{${modelHash(ref.name)}}`;
+			case "enum": {
+				const vh = enumVH.get(ref.name);
+				return vh != null ? `e:{${vh}}` : `e:${ref.name}`;
+			}
+			case "array": return `a:${deepTypeHash(ref.items)}`;
+			case "nullable": return `n:${deepTypeHash(ref.inner)}`;
+			case "union": return `u:${(ref.variants ?? []).map((v) => deepTypeHash(v)).sort().join(",")}`;
+			case "map": return `d:${deepTypeHash(ref.valueType)}`;
+			case "literal": return `l:${String(ref.value)}`;
+			default: return "unknown";
+		}
+	}
+	for (const model of models) modelHash(model.name);
+	return hashCache;
+}
+/**
+* Natural enum-to-service assignment without sharing logic — the first service
+* (alphabetically by spec order) to reference an enum wins.
+*/
+function assignEnumsToServicesNatural(enums, services) {
+	const enumNames = new Set(enums.map((e) => e.name));
+	const enumToService = /* @__PURE__ */ new Map();
+	for (const service of services) {
+		const refs = /* @__PURE__ */ new Set();
+		const collect = (ref) => {
+			walkTypeRef(ref, { enum: (r) => refs.add(r.name) });
+		};
+		for (const op of service.operations) {
+			if (op.requestBody) collect(op.requestBody);
+			collect(op.response);
+			for (const p of [
+				...op.pathParams,
+				...op.queryParams,
+				...op.headerParams,
+				...op.cookieParams ?? []
+			]) collect(p.type);
+		}
+		for (const name of refs) {
+			if (!enumNames.has(name)) continue;
+			if (!enumToService.has(name)) enumToService.set(name, service.name);
+		}
+	}
+	return enumToService;
+}
+//#endregion
 //#region src/python/enums.ts
 /**
 * Convert a PascalCase class name to a human-readable lowercase string,
@@ -6940,12 +7264,16 @@ function humanizeClassName(name) {
 */
 function generateEnums$5(enums, ctx) {
 	if (enums.length === 0) return [];
-	const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+	const placement = computeSchemaPlacement(enums === ctx.spec.enums ? ctx.spec : {
+		...ctx.spec,
+		enums
+	}, ctx);
+	const enumToService = placement.enumToService;
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? mountDirMap.get(irService) ?? "common" : "common";
 	const files = [];
 	const compatAliases = collectCompatEnumAliases(enums, ctx);
-	const aliasOf = collectEnumAliasOf$3(enums);
+	const aliasOf = placement.enumAliases;
 	for (const enumDef of enums) {
 		const dirName = resolveDir(enumToService.get(enumDef.name));
 		const canonicalName = aliasOf.get(enumDef.name);
@@ -7110,24 +7438,11 @@ function collectCompatEnumAliases(enums, ctx) {
 	}
 	return aliases;
 }
-function collectEnumAliasOf$3(enums) {
-	const hashGroups = /* @__PURE__ */ new Map();
-	for (const enumDef of enums) {
-		const hash = [...enumDef.values].map((v) => String(v.value)).sort().join("|");
-		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
-		hashGroups.get(hash).push(enumDef.name);
-	}
-	const aliasOf = /* @__PURE__ */ new Map();
-	for (const [, names] of hashGroups) {
-		if (names.length <= 1) continue;
-		const sorted = [...names].sort();
-		const canonical = sorted[0];
-		for (let i = 1; i < sorted.length; i++) aliasOf.set(sorted[i], canonical);
-	}
-	return aliasOf;
-}
 function collectGeneratedEnumSymbolsByDir(enums, ctx) {
-	const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+	const enumToService = computeSchemaPlacement(enums === ctx.spec.enums ? ctx.spec : {
+		...ctx.spec,
+		enums
+	}, ctx).enumToService;
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? mountDirMap.get(irService) ?? "common" : "common";
 	const compatAliases = collectCompatEnumAliases(enums, ctx);
@@ -7143,26 +7458,6 @@ function collectGeneratedEnumSymbolsByDir(enums, ctx) {
 function enumValueHash(enumDef) {
 	return [...enumDef.values].map((value) => String(value.value)).sort().join("|");
 }
-function assignEnumsToServices(enums, services) {
-	const enumToService = /* @__PURE__ */ new Map();
-	const enumNames = new Set(enums.map((e) => e.name));
-	for (const service of services) for (const op of service.operations) {
-		const refs = /* @__PURE__ */ new Set();
-		const collect = (ref) => {
-			walkTypeRef(ref, { enum: (r) => refs.add(r.name) });
-		};
-		if (op.requestBody) collect(op.requestBody);
-		collect(op.response);
-		for (const p of [
-			...op.pathParams,
-			...op.queryParams,
-			...op.headerParams,
-			...op.cookieParams ?? []
-		]) collect(p.type);
-		for (const name of refs) if (enumNames.has(name) && !enumToService.has(name)) enumToService.set(name, service.name);
-	}
-	return enumToService;
-}
 //#endregion
 //#region src/python/models.ts
 /**
@@ -7171,29 +7466,16 @@ function assignEnumsToServices(enums, services) {
 */
 function generateModels$5(models, ctx) {
 	if (models.length === 0) return [];
-	const modelToService = assignModelsToServices(models, ctx.spec.services, ctx.modelHints);
-	const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
+	const { modelToService, enumToService, originalModelToService, originalEnumToService, relocatedModels, relocatedEnums, modelAliases: aliasOf } = computeSchemaPlacement(models === ctx.spec.models ? ctx.spec : {
+		...ctx.spec,
+		models
+	}, ctx);
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? mountDirMap.get(irService) ?? "common" : "common";
 	const files = [];
 	const emittedModelSymbolsByDir = /* @__PURE__ */ new Map();
 	const symbolToFile = /* @__PURE__ */ new Map();
-	const modelUsage = collectModelUsage(ctx.spec);
-	const recursiveHashes = buildRecursiveHashMap$1(models, ctx.spec.enums);
-	const hashGroups = /* @__PURE__ */ new Map();
-	for (const model of models) {
-		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
-		const hash = recursiveHashes.get(model.name) ?? "";
-		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
-		hashGroups.get(hash).push(model.name);
-	}
-	const aliasOf = /* @__PURE__ */ new Map();
-	for (const [, names] of hashGroups) {
-		if (names.length <= 1) continue;
-		const sorted = [...names].sort((a, b) => compareAliasPriority(a, b, modelUsage));
-		const canonical = sorted[0];
-		for (let i = 1; i < sorted.length; i++) if (canAliasModels(canonical, sorted[i], modelUsage)) aliasOf.set(sorted[i], canonical);
-	}
+	const symbolToOriginalService = /* @__PURE__ */ new Map();
 	const emittedFilePaths = /* @__PURE__ */ new Set();
 	for (const model of models) {
 		if (isListWrapperModel(model)) continue;
@@ -7282,6 +7564,12 @@ function generateModels$5(models, ctx) {
 			symbolToFile.set(variantTypeName, fileName$2(model.name));
 			emittedModelSymbolsByDir.get(dirName).push(unknownClassName);
 			symbolToFile.set(unknownClassName, fileName$2(model.name));
+			const dispatcherNatural = originalModelToService.get(model.name);
+			if (dispatcherNatural) {
+				symbolToOriginalService.set(model.name, dispatcherNatural);
+				symbolToOriginalService.set(variantTypeName, dispatcherNatural);
+				symbolToOriginalService.set(unknownClassName, dispatcherNatural);
+			}
 			continue;
 		}
 		const canonicalName = aliasOf.get(model.name);
@@ -7303,6 +7591,8 @@ function generateModels$5(models, ctx) {
 			});
 			if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
 			emittedModelSymbolsByDir.get(dirName).push(model.name);
+			const aliasNatural = originalModelToService.get(model.name);
+			if (aliasNatural) symbolToOriginalService.set(model.name, aliasNatural);
 			continue;
 		}
 		const seenFieldNames = /* @__PURE__ */ new Set();
@@ -7387,19 +7677,29 @@ function generateModels$5(models, ctx) {
 		lines.push(`    def from_dict(cls, data: Dict[str, Any]) -> "${modelClassName}":`);
 		lines.push(`        """Deserialize from a dictionary."""`);
 		lines.push("        try:");
-		lines.push("            return cls(");
+		const preludeLines = [];
+		const fieldAssignmentLines = [];
 		for (const field of [...requiredFields, ...optionalFields]) {
 			const pyFieldName = fieldName$4(field.name);
 			const wireKey = field.name;
 			const isRequired = !isOptionalField(model.name, field, ctx);
+			const discPrelude = renderDiscriminatedUnionPrelude(field, pyFieldName, wireKey, modelClassName, isRequired);
+			if (discPrelude) {
+				preludeLines.push(...discPrelude.prelude);
+				fieldAssignmentLines.push(`                ${pyFieldName}=${discPrelude.expr},`);
+				continue;
+			}
 			let accessor;
 			if (field.type.kind === "literal" && isRequired) accessor = `data.get("${wireKey}", ${pythonLiteralDefault(field.type.value)})`;
 			else accessor = isRequired ? `data["${wireKey}"]` : `data.get("${wireKey}")`;
 			const deserRequired = isRequired && field.type.kind !== "nullable";
 			const walrusVar = `_v_${pyFieldName}`;
 			const deserExpr = deserializeField(field.type, accessor, deserRequired, walrusVar);
-			lines.push(`                ${pyFieldName}=${deserExpr},`);
+			fieldAssignmentLines.push(`                ${pyFieldName}=${deserExpr},`);
 		}
+		for (const preludeLine of preludeLines) lines.push(preludeLine);
+		lines.push("            return cls(");
+		for (const assignment of fieldAssignmentLines) lines.push(assignment);
 		lines.push("            )");
 		lines.push("        except (KeyError, ValueError) as e:");
 		lines.push(`            _raise_deserialize_error("${modelClassName}", e)`);
@@ -7437,20 +7737,45 @@ function generateModels$5(models, ctx) {
 		});
 		if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
 		emittedModelSymbolsByDir.get(dirName).push(model.name);
+		const regularNatural = originalModelToService.get(model.name);
+		if (regularNatural) symbolToOriginalService.set(model.name, regularNatural);
 	}
 	const symbolsByDir = /* @__PURE__ */ new Map();
 	for (const [dirName, names] of emittedModelSymbolsByDir) {
 		const key = `src/${ctx.namespace}/${dirName}/models`;
 		if (!symbolsByDir.has(key)) symbolsByDir.set(key, []);
-		symbolsByDir.get(key).push(...names);
+		for (const name of names) symbolsByDir.get(key).push({ name });
 	}
 	const reachableEnumNames = collectReachableEnumNames(ctx);
 	const enumSymbolsByDir = collectGeneratedEnumSymbolsByDir(ctx.spec.enums.filter((enumDef) => reachableEnumNames.has(enumDef.name)), ctx);
 	for (const [dirName, names] of enumSymbolsByDir) {
 		const key = `src/${ctx.namespace}/${dirName}/models`;
 		if (!symbolsByDir.has(key)) symbolsByDir.set(key, []);
-		symbolsByDir.get(key).push(...names);
-	}
+		for (const name of names) symbolsByDir.get(key).push({ name });
+	}
+	const commonDirName = "common";
+	const addReExport = (naturalService, name, sourceFile) => {
+		if (!naturalService) return;
+		const naturalDir = mountDirMap.get(naturalService) ?? naturalService;
+		if (naturalDir === commonDirName) return;
+		const key = `src/${ctx.namespace}/${naturalDir}/models`;
+		if (!symbolsByDir.has(key)) symbolsByDir.set(key, []);
+		symbolsByDir.get(key).push({
+			name,
+			reExport: {
+				fromDir: commonDirName,
+				file: sourceFile
+			}
+		});
+	};
+	for (const symbol of symbolToOriginalService.keys()) {
+		const naturalService = symbolToOriginalService.get(symbol);
+		const file = symbolToFile.get(symbol) ?? fileName$2(symbol);
+		const primaryName = file === fileName$2(symbol) ? symbol : reverseLookupModelByFile(file, ctx);
+		if (primaryName && !relocatedModels.has(primaryName)) continue;
+		addReExport(naturalService, symbol, file);
+	}
+	for (const enumName of relocatedEnums) addReExport(originalEnumToService.get(enumName), enumName, fileName$2(enumName));
 	const serviceDirModelPaths = /* @__PURE__ */ new Set();
 	for (const service of ctx.spec.services) {
 		const dirName = mountDirMap.get(service.name) ?? resolveDir(service.name);
@@ -7462,12 +7787,21 @@ function generateModels$5(models, ctx) {
 		integrateTarget: true,
 		overwriteExisting: true
 	});
-	for (const [dirPath, names] of symbolsByDir) {
-		const uniqueNames = [...new Set(names)].sort();
+	for (const [dirPath, symbols] of symbolsByDir) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const sym of symbols) {
+			const existing = seen.get(sym.name);
+			if (!existing || existing.reExport && !sym.reExport) seen.set(sym.name, sym);
+		}
+		const uniqueSymbols = [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
 		const importLines = [];
-		for (const name of uniqueNames) {
-			const fileNameForSymbol = symbolToFile.get(name) ?? fileName$2(name);
-			importLines.push(`from .${fileNameForSymbol} import ${className$5(name)} as ${className$5(name)}`);
+		for (const sym of uniqueSymbols) {
+			const cls = className$5(sym.name);
+			if (sym.reExport) importLines.push(`from ${ctx.namespace}.${dirToModule(sym.reExport.fromDir)}.models.${sym.reExport.file} import ${cls} as ${cls}`);
+			else {
+				const fileNameForSymbol = symbolToFile.get(sym.name) ?? fileName$2(sym.name);
+				importLines.push(`from .${fileNameForSymbol} import ${cls} as ${cls}`);
+			}
 		}
 		const imports = importLines.join("\n");
 		files.push({
@@ -7478,7 +7812,7 @@ function generateModels$5(models, ctx) {
 		});
 		if (!serviceDirModelPaths.has(dirPath)) {
 			const parentDir = dirPath.replace(/\/models$/, "");
-			const reExports = [...new Set(names)].sort().map((name) => `from .models import ${className$5(name)} as ${className$5(name)}`).join("\n");
+			const reExports = uniqueSymbols.map((sym) => `from .models import ${className$5(sym.name)} as ${className$5(sym.name)}`).join("\n");
 			files.push({
 				path: `${parentDir}/__init__.py`,
 				content: reExports,
@@ -7489,6 +7823,14 @@ function generateModels$5(models, ctx) {
 	}
 	return files;
 }
+/**
+* Given a snake_case file name, return the IR model name that owns it.
+* Used to attribute dispatcher children (FooVariant, FooUnknown) to their
+* parent model when computing relocation re-exports.
+*/
+function reverseLookupModelByFile(file, ctx) {
+	for (const m of ctx.spec.models) if (fileName$2(m.name) === file) return m.name;
+}
 function collectTypingImports(ref, imports) {
 	switch (ref.kind) {
 		case "array":
@@ -7553,42 +7895,6 @@ function collectReachableEnumNames(ctx) {
 	}
 	return referencedEnums;
 }
-function collectModelUsage(spec) {
-	const request = /* @__PURE__ */ new Set();
-	const response = /* @__PURE__ */ new Set();
-	for (const service of spec.services) for (const op of service.operations) {
-		const plan = planOperation(op);
-		if (plan.responseModelName) response.add(plan.responseModelName);
-		if (op.pagination?.itemType.kind === "model") response.add(op.pagination.itemType.name);
-		if (op.requestBody?.kind === "model") request.add(op.requestBody.name);
-		if (op.requestBody?.kind === "union") {
-			for (const variant of op.requestBody.variants ?? []) if (variant.kind === "model") request.add(variant.name);
-		}
-	}
-	const mixed = /* @__PURE__ */ new Set();
-	for (const name of request) if (response.has(name)) mixed.add(name);
-	return {
-		requestOnly: new Set([...request].filter((name) => !mixed.has(name))),
-		response: new Set([...response].filter((name) => !mixed.has(name))),
-		mixed
-	};
-}
-function compareAliasPriority(left, right, usage) {
-	const score = (name) => {
-		if (usage.response.has(name)) return 0;
-		if (usage.mixed.has(name)) return 1;
-		if (usage.requestOnly.has(name)) return 2;
-		return 3;
-	};
-	const diff = score(left) - score(right);
-	if (diff !== 0) return diff;
-	return left.localeCompare(right);
-}
-function canAliasModels(canonical, alias, usage) {
-	if (fileName$2(canonical) === fileName$2(alias)) return false;
-	if (usage.response.has(canonical) && usage.requestOnly.has(alias) || usage.response.has(alias) && usage.requestOnly.has(canonical)) return false;
-	return true;
-}
 function isOptionalField(modelName, field, ctx) {
 	if (!field.required || field.deprecated) return true;
 	return false;
@@ -7609,6 +7915,71 @@ function isDateTimeType(ref) {
 	if (ref.kind === "nullable") return isDateTimeType(ref.inner);
 	return ref.kind === "primitive" && ref.type === "string" && ref.format === "date-time";
 }
+/**
+* If `field` is a discriminated-union (or nullable-wrapped discriminated-union)
+* field, return prelude statements that perform strict dispatch and an
+* expression for the `cls(...)` call. Returns null otherwise.
+*
+* Strict dispatch means: an unknown discriminator value raises ValueError
+* naming the parent class, field, observed value, and valid options. The
+* caller's `try/except` block converts that into `_raise_deserialize_error`.
+*/
+function renderDiscriminatedUnionPrelude(field, pyFieldName, wireKey, parentClassName, isRequired) {
+	let unionRef = null;
+	let nullable = false;
+	if (field.type.kind === "union" && field.type.discriminator?.mapping) unionRef = field.type;
+	else if (field.type.kind === "nullable" && field.type.inner.kind === "union" && field.type.inner.discriminator?.mapping) {
+		unionRef = field.type.inner;
+		nullable = true;
+	}
+	if (!unionRef) return null;
+	const mapping = unionRef.discriminator.mapping;
+	const entries = Object.entries(mapping);
+	if (entries.length === 0) return null;
+	const discProp = unionRef.discriminator.property;
+	const rawVar = `_${pyFieldName}_raw`;
+	const dataVar = `_${pyFieldName}_data`;
+	const typeVar = `_${pyFieldName}_disc`;
+	const mapVar = `_${pyFieldName}_disc_map`;
+	const clsVar = `_${pyFieldName}_cls`;
+	const valueVar = `_${pyFieldName}_value`;
+	const indent = "            ";
+	const dispatchBlock = (innerIndent) => {
+		const lines = [];
+		lines.push(`${innerIndent}${dataVar} = cast(Dict[str, Any], ${rawVar})`);
+		lines.push(`${innerIndent}${typeVar} = cast(str, ${dataVar}.get("${discProp}"))`);
+		lines.push(`${innerIndent}${mapVar}: Dict[str, Any] = {`);
+		for (const [value, variantModelName] of entries) lines.push(`${innerIndent}    "${value}": ${className$5(variantModelName)},`);
+		lines.push(`${innerIndent}}`);
+		lines.push(`${innerIndent}${clsVar} = ${mapVar}.get(${typeVar})`);
+		lines.push(`${innerIndent}if ${clsVar} is None:`);
+		lines.push(`${innerIndent}    raise ValueError(`);
+		lines.push(`${innerIndent}        f"Unknown discriminator '${discProp}' for ${parentClassName}.${pyFieldName}: {${typeVar}!r}. "`);
+		lines.push(`${innerIndent}        f"Expected one of {sorted(${mapVar})}."`);
+		lines.push(`${innerIndent}    )`);
+		return lines;
+	};
+	const prelude = [];
+	if (isRequired && !nullable) {
+		prelude.push(`${indent}${rawVar} = data["${wireKey}"]`);
+		prelude.push(...dispatchBlock(indent));
+		return {
+			prelude,
+			expr: `${clsVar}.from_dict(${dataVar})`
+		};
+	}
+	const accessor = isRequired ? `data["${wireKey}"]` : `data.get("${wireKey}")`;
+	prelude.push(`${indent}${rawVar} = ${accessor}`);
+	prelude.push(`${indent}if ${rawVar} is None:`);
+	prelude.push(`${indent}    ${valueVar} = None`);
+	prelude.push(`${indent}else:`);
+	prelude.push(...dispatchBlock(indent + "    "));
+	prelude.push(`${indent}    ${valueVar} = ${clsVar}.from_dict(${dataVar})`);
+	return {
+		prelude,
+		expr: valueVar
+	};
+}
 function deserializeField(ref, accessor, isRequired, walrusVar = "_v") {
 	if (isDateTimeType(ref)) {
 		if (isRequired) return `_parse_datetime(${accessor})`;
@@ -7639,17 +8010,6 @@ function deserializeField(ref, accessor, isRequired, walrusVar = "_v") {
 		case "union": {
 			const modelVariants = (ref.variants ?? []).filter((v) => v.kind === "model");
 			const uniqueModels = [...new Set(modelVariants.map((v) => v.name))];
-			if (ref.discriminator && ref.discriminator.mapping) {
-				const entries = Object.entries(ref.discriminator.mapping);
-				if (entries.length > 0) {
-					const dispatchMap = entries.map(([value, modelName]) => `"${value}": ${className$5(modelName)}`).join(", ");
-					const dataExpr = isRequired ? accessor : walrusVar;
-					const dataCast = `cast(Dict[str, Any], ${dataExpr})`;
-					const branch = `(_disc.from_dict(${dataCast}) if (_disc := ${`{${dispatchMap}}.get(cast(str, ${dataCast}.get("${ref.discriminator.property}")))`}) is not None else ${dataExpr})`;
-					if (isRequired) return branch;
-					return `(${branch}) if (${walrusVar} := ${accessor}) is not None else None`;
-				}
-			}
 			if (uniqueModels.length === 1) return deserializeField({
 				kind: "model",
 				name: uniqueModels[0]
@@ -7671,61 +8031,12 @@ function serializeField(ref, accessor) {
 		case "union": {
 			const modelVariants = (ref.variants ?? []).filter((v) => v.kind === "model");
 			if ([...new Set(modelVariants.map((v) => v.name))].length === 1) return `${accessor}.to_dict()`;
-			if (ref.discriminator && ref.discriminator.mapping && modelVariants.length > 0) return `${accessor}.to_dict() if hasattr(${accessor}, "to_dict") else ${accessor}`;
+			if (ref.discriminator && ref.discriminator.mapping && modelVariants.length > 0) return `${accessor}.to_dict()`;
 			return accessor;
 		}
 		default: return accessor;
 	}
 }
-/**
-* Build recursive structural hashes for all models.
-*
-* Model references are resolved to their own structural hash (bottom-up) and
-* enum references are resolved to their value-set hash.  This means
-* structurally-identical model *trees* — like the dozens of per-event Context /
-* ContextActor / ContextGoogleAnalyticsSession sub-models in the spec — get
-* the same hash even though their IR names differ.
-*/
-function buildRecursiveHashMap$1(models, enums) {
-	const modelByName = new Map(models.map((m) => [m.name, m]));
-	const hashCache = /* @__PURE__ */ new Map();
-	const visiting = /* @__PURE__ */ new Set();
-	const enumVH = /* @__PURE__ */ new Map();
-	for (const e of enums) enumVH.set(e.name, [...e.values].map((v) => String(v.value)).sort().join("|"));
-	function modelHash(name) {
-		const cached = hashCache.get(name);
-		if (cached != null) return cached;
-		if (visiting.has(name)) return `m:${name}`;
-		visiting.add(name);
-		const model = modelByName.get(name);
-		if (!model) {
-			visiting.delete(name);
-			return `m:${name}`;
-		}
-		const hash = [...model.fields].sort((a, b) => a.name.localeCompare(b.name)).map((f) => `${f.name}:${deepTypeHash(f.type)}:${f.required}`).join("|");
-		visiting.delete(name);
-		hashCache.set(name, hash);
-		return hash;
-	}
-	function deepTypeHash(ref) {
-		switch (ref.kind) {
-			case "primitive": return `p:${ref.type}${ref.format ? `:${ref.format}` : ""}`;
-			case "model": return `m:{${modelHash(ref.name)}}`;
-			case "enum": {
-				const vh = enumVH.get(ref.name);
-				return vh != null ? `e:{${vh}}` : `e:${ref.name}`;
-			}
-			case "array": return `a:${deepTypeHash(ref.items)}`;
-			case "nullable": return `n:${deepTypeHash(ref.inner)}`;
-			case "union": return `u:${(ref.variants ?? []).map((v) => deepTypeHash(v)).sort().join(",")}`;
-			case "map": return `d:${deepTypeHash(ref.valueType)}`;
-			case "literal": return `l:${String(ref.value)}`;
-			default: return "unknown";
-		}
-	}
-	for (const model of models) modelHash(model.name);
-	return hashCache;
-}
 //#endregion
 //#region src/python/path-expression.ts
 /**
@@ -8031,7 +8342,9 @@ function emitMethodSignature(lines, op, plan, method, isAsync, specEnumNames, mo
 		lines.push("        after: Optional[str] = None,");
 		const orderParam = op.queryParams.find((p) => p.name === "order");
 		const orderType = orderParam && orderParam.type.kind === "enum" ? mapTypeRefUnquoted(orderParam.type, specEnumNames, true) : "str";
-		lines.push(`        order: Optional[${orderType}] = "desc",`);
+		const orderDefaultRaw = orderParam?.default;
+		const orderDefault = typeof orderDefaultRaw === "string" || typeof orderDefaultRaw === "number" || typeof orderDefaultRaw === "boolean" ? pythonLiteral(orderDefaultRaw) : "None";
+		lines.push(`        order: Optional[${orderType}] = ${orderDefault},`);
 		for (const param of op.queryParams) {
 			if ([
 				"limit",
@@ -8578,7 +8891,8 @@ function generateResources$5(services, ctx) {
 		if (enumImports.size > 0) lines.push(`from ${importPrefix}_types import RequestOptions, enum_value`);
 		else lines.push(`from ${importPrefix}_types import RequestOptions`);
 		const actualModelImports = [...modelImports];
-		const modelToServiceMap = assignModelsToServices(ctx.spec.models, ctx.spec.services, ctx.modelHints);
+		const placement = computeSchemaPlacement(ctx.spec, ctx);
+		const modelToServiceMap = new Map(placement.modelToService);
 		for (const model of ctx.spec.models) if (model.discriminator) {
 			const svc = modelToServiceMap.get(model.name);
 			if (svc) modelToServiceMap.set(model.name + "Variant", svc);
@@ -8603,19 +8917,7 @@ function generateResources$5(services, ctx) {
 			const unique = names.filter((n) => !localSet.has(n));
 			for (const n of unique) lines.push(`from ${ctx.namespace}.${dirToModule(csDir)}.models.${fileName$2(n)} import ${className$5(n)}`);
 		}
-		const enumToServiceMap = /* @__PURE__ */ new Map();
-		for (const e of ctx.spec.enums) for (const svc of ctx.spec.services) for (const op of svc.operations) {
-			const refs = /* @__PURE__ */ new Set();
-			const allTypeRefs = [
-				op.response,
-				...op.requestBody ? [op.requestBody] : [],
-				...op.pathParams.map((p) => p.type),
-				...op.queryParams.map((p) => p.type),
-				...op.headerParams.map((p) => p.type)
-			];
-			for (const typeRef of allTypeRefs) for (const ref of collectEnumRefs(typeRef)) refs.add(ref);
-			if (refs.has(e.name) && !enumToServiceMap.has(e.name)) enumToServiceMap.set(e.name, svc.name);
-		}
+		const enumToServiceMap = placement.enumToService;
 		const localEnums = [];
 		const crossServiceEnums = /* @__PURE__ */ new Map();
 		for (const name of [...enumImports].sort()) {
@@ -9387,13 +9689,14 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 		if (!model) return true;
 		return !isListWrapperModel(model);
 	});
-	const modelToServiceMap = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
+	const placement = computeSchemaPlacement(spec, ctx);
+	const modelToServiceMap = placement.modelToService;
+	const enumToServiceMap = placement.enumToService;
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveModelDir = (modelName) => {
 		const svc = modelToServiceMap.get(modelName);
 		return svc ? mountDirMap.get(svc) ?? "common" : "common";
 	};
-	const enumToServiceMap = assignEnumsToServices(spec.enums, spec.services);
 	const resolveEnumDir = (enumName) => {
 		const svc = enumToServiceMap.get(enumName);
 		return svc ? mountDirMap.get(svc) ?? "common" : "common";
@@ -10237,7 +10540,7 @@ function generateModelRoundTripTests(spec, ctx) {
 	for (const name of responseModelNames) requestOnlyModelNames.delete(name);
 	const models = spec.models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m) && !requestOnlyModelNames.has(m.name));
 	if (models.length === 0) return null;
-	const modelToService = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
+	const modelToService = computeSchemaPlacement(spec, ctx).originalModelToService;
 	const roundTripDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? roundTripDirMap.get(irService) ?? "common" : "common";
 	const lines = [];
@@ -10798,7 +11101,8 @@ function generateFromArrayValue(ref, accessor) {
 				const entries = Object.entries(ref.discriminator.mapping);
 				if (entries.length > 0) {
 					const arms = entries.map(([value, modelName]) => `'${value}' => ${className$4(modelName)}::fromArray(${accessor})`).join(", ");
-					return `match (${accessor}['${ref.discriminator.property}'] ?? null) { ${arms}, default => ${accessor} }`;
+					const discProp = ref.discriminator.property;
+					return `match (${accessor}['${discProp}'] ?? null) { ${arms}, ${`default => throw new \\UnexpectedValueException(sprintf('Unknown ${discProp}: %s', json_encode(${accessor}['${discProp}'] ?? null)))`} }`;
 				}
 			}
 			const resolved = resolveDegenerateUnion(ref);
@@ -10854,6 +11158,11 @@ function generateToArrayValue(ref, accessor, nullable = false) {
 		case "union": {
 			const resolved = resolveDegenerateUnion(ref);
 			if (resolved) return generateToArrayValue(resolved, accessor, nullable);
+			if (ref.variants.every((v) => v.kind === "model")) return `${accessor}${ns}->toArray()`;
+			if (ref.variants.some((v) => v.kind === "model" || v.kind === "enum")) {
+				const summary = ref.variants.map((v) => v.kind === "model" ? `model:${v.name}` : v.kind === "enum" ? `enum:${v.name}` : v.kind).join(" | ");
+				throw new Error(`[php emitter] Cannot generate toArray for heterogeneous union: ${summary}. Unions must be all-model or all-scalar; mixed and all-enum unions are not yet supported.`);
+			}
 			return accessor;
 		}
 		case "literal": return accessor;
@@ -11235,8 +11544,8 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 		const phpName = fieldName$3(q.name);
 		if (seenDocParams.has(phpName)) continue;
 		seenDocParams.add(phpName);
-		const isNonNullableOrder = q.name === "order" && q.type.kind === "enum";
-		const nullSuffix = !q.required && !isNonNullableOrder && !docType.endsWith("|null") ? "|null" : "";
+		const hasEnumDefault = q.default != null && q.type.kind === "enum";
+		const nullSuffix = !q.required && !hasEnumDefault && !docType.endsWith("|null") ? "|null" : "";
 		const prefix = q.deprecated ? "(deprecated) " : "";
 		let desc = q.description ? ` ${prefix}${q.description}` : q.deprecated ? " (deprecated)" : "";
 		if (q.default != null) desc += ` Defaults to ${JSON.stringify(q.default)}.`;
@@ -11458,15 +11767,11 @@ function buildMethodParams(op, plan, modelMap, ctx, hiddenParams) {
 		if (usedNames.has(phpName)) continue;
 		usedNames.add(phpName);
 		if (q.required) required.push(`${phpType} $${phpName}`);
-		else if (q.name === "order") if (q.type.kind === "enum") {
+		else if (q.default != null && q.type.kind === "enum") {
 			const enumType = mapTypeRef$4(q.type, { qualified: true });
-			const caseName = toPascalCase("desc");
+			const caseName = toPascalCase(String(q.default));
 			optional.push(`${enumType} $${phpName} = ${enumType}::${caseName}`);
 		} else {
-			const nullableType = phpType.startsWith("?") ? phpType : `?${phpType}`;
-			optional.push(`${nullableType} $${phpName} = 'desc'`);
-		}
-		else {
 			const nullableType = phpType.startsWith("?") ? phpType : `?${phpType}`;
 			optional.push(`${nullableType} $${phpName} = null`);
 		}
@@ -11514,8 +11819,8 @@ function buildQueryArray(op, hiddenParams) {
 	return op.queryParams.filter((q) => !hidden.has(q.name) && !groupedParams.has(q.name)).map((q) => {
 		const phpName = fieldName$3(q.name);
 		if (isEnumType(q.type)) {
-			const isNonNullableOrder = q.name === "order" && q.type.kind === "enum";
-			const nullsafe = q.required || isNonNullableOrder ? "" : "?";
+			const hasEnumDefault = q.default != null && q.type.kind === "enum";
+			const nullsafe = q.required || hasEnumDefault ? "" : "?";
 			return `'${q.name}' => $${phpName}${nullsafe}->value,`;
 		}
 		return `'${q.name}' => $${phpName},`;
@@ -12611,6 +12916,8 @@ function generateModels$3(models, ctx) {
 		lines.push("}");
 		lines.push("");
 	}
+	const orderEnumType = detectSharedOrderEnum(ctx.spec.services);
+	const orderGoType = orderEnumType ? `*${className$3(orderEnumType)}` : "*string";
 	lines.push("// PaginationParams contains common pagination parameters for list operations.");
 	lines.push("type PaginationParams struct {");
 	lines.push("	// Before is a cursor for reverse pagination.");
@@ -12619,8 +12926,8 @@ function generateModels$3(models, ctx) {
 	lines.push("	After *string `url:\"after,omitempty\" json:\"-\"`");
 	lines.push("	// Limit is the maximum number of items to return per page.");
 	lines.push("	Limit *int `url:\"limit,omitempty\" json:\"-\"`");
-	lines.push("	// Order is the sort order for results (asc or desc).");
-	lines.push("	Order *string `url:\"order,omitempty\" json:\"-\"`");
+	lines.push("	// Order is the sort order for results.");
+	lines.push(`\tOrder ${orderGoType} \`url:"order,omitempty" json:"-"\``);
 	lines.push("}");
 	lines.push("");
 	files.push({
@@ -12700,6 +13007,38 @@ function lowerFirst$1(s) {
 	return lowerFirstForDoc(s);
 }
 /**
+* If every paginated list operation's `order` query parameter $refs the same
+* top-level enum, return that enum's IR name. Otherwise return null. When
+* the spec is consistent this lifts `PaginationParams.Order` from `*string`
+* to `*PaginationOrder` (or whatever the spec calls it), giving callers
+* compile-time validation.
+*
+* We require strict consistency: if any operation uses a primitive string for
+* `order`, or two operations reference different enums, we conservatively
+* stay on `*string` so the shared struct doesn't lie about its accepted
+* values.
+*/
+function detectSharedOrderEnum(services) {
+	let candidate = null;
+	let sawAny = false;
+	for (const service of services) for (const op of service.operations) {
+		if (!op.pagination) continue;
+		const orderParam = op.queryParams.find((p) => p.name === "order");
+		if (!orderParam) continue;
+		sawAny = true;
+		const enumName = unwrapEnumName(orderParam.type);
+		if (!enumName) return null;
+		if (candidate === null) candidate = enumName;
+		else if (candidate !== enumName) return null;
+	}
+	return sawAny ? candidate : null;
+}
+function unwrapEnumName(ref) {
+	if (ref.kind === "enum") return ref.name;
+	if (ref.kind === "nullable") return unwrapEnumName(ref.inner);
+	return null;
+}
+/**
 * Extract a deprecation reason from a field description.
 * Looks for patterns like "Use X instead", "Replaced by Y", etc.
 * Falls back to a generic message if no migration guidance is found.
@@ -15558,15 +15897,22 @@ function generateEnums$2(enums, ctx) {
 		lines.push("    [STJS.JsonConverter(typeof(WorkOSStringEnumConverterFactory))]");
 		lines.push(`    public enum ${typeName}`);
 		lines.push("    {");
-		lines.push(`        [EnumMember(Value = "unknown")]`);
-		lines.push(`        Unknown,`);
-		lines.push("");
+		const defaultMatch = enumDef.default !== void 0 ? uniqueValues.find((v) => v.value === enumDef.default) : void 0;
+		const orderedValues = defaultMatch ? [defaultMatch, ...uniqueValues.filter((v) => v !== defaultMatch)] : uniqueValues;
 		const usedNames = /* @__PURE__ */ new Set();
-		usedNames.add("Unknown");
 		const usedWireValues = /* @__PURE__ */ new Set();
-		usedWireValues.add("unknown");
-		for (let i = 0; i < uniqueValues.length; i++) {
-			const v = uniqueValues[i];
+		if (defaultMatch) {
+			usedNames.add("Unknown");
+			usedWireValues.add("unknown");
+		} else {
+			lines.push(`        [EnumMember(Value = "unknown")]`);
+			lines.push(`        Unknown,`);
+			lines.push("");
+			usedNames.add("Unknown");
+			usedWireValues.add("unknown");
+		}
+		for (let i = 0; i < orderedValues.length; i++) {
+			const v = orderedValues[i];
 			if (usedWireValues.has(String(v.value))) continue;
 			usedWireValues.add(String(v.value));
 			let memberName = className$2(String(v.value));
@@ -15582,8 +15928,13 @@ function generateEnums$2(enums, ctx) {
 				lines.push(`        [System.Obsolete("${msg}")]`);
 			}
 			lines.push(`        [EnumMember(Value = "${v.value}")]`);
-			const comma = i < uniqueValues.length - 1 ? "," : ",";
-			lines.push(`        ${memberName}${comma}`);
+			const ordinal = defaultMatch ? ` = ${i}` : "";
+			lines.push(`        ${memberName}${ordinal},`);
+		}
+		if (defaultMatch) {
+			lines.push("");
+			lines.push(`        [EnumMember(Value = "unknown")]`);
+			lines.push(`        Unknown = 99,`);
 		}
 		lines.push("    }");
 		lines.push("}");
@@ -21415,7 +21766,7 @@ function emitMethod(args) {
 		const n = safeParamName(q.name);
 		if (seenParamNames.has(n)) continue;
 		seenParamNames.add(n);
-		const defaultVal = q.name === "order" ? rubyStringLit("desc") : "nil";
+		const defaultVal = q.default != null ? rubyDefaultLiteral(q.default) : "nil";
 		sigParts.push(`${n}: ${defaultVal}`);
 	}
 	for (const group of op.parameterGroups ?? []) {
@@ -21795,6 +22146,14 @@ function buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bod
 function rubyStringLit(s) {
 	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
+/** Render an arbitrary spec-default value as a Ruby literal for a method-arg default. */
+function rubyDefaultLiteral(value) {
+	if (typeof value === "string") return rubyStringLit(value);
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : "nil";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (value === null) return "nil";
+	return "nil";
+}
 /**
 * Build a Ruby double-quoted string expression for the `else raise ArgumentError`
 * arm of a parameter-group dispatcher. Lists the expected variant classes and
@@ -22800,4 +23159,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { nodeEmitter as _, rustExtractor as a, pythonExtractor as c, rubyEmitter as d, kotlinEmitter as f, pythonEmitter as g, phpEmitter as h, kotlinExtractor as i, rubyExtractor as l, goEmitter as m, elixirExtractor as n, goExtractor as o, dotnetEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u };
 
-//# sourceMappingURL=plugin-Dh9JSScr.mjs.map
+//# sourceMappingURL=plugin-DW3cnedr.mjs.map