@workos/oagen-emitters 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { assignModelsToServices, assignModelsToServices as assignModelsToServices$1, collectFieldDependencies, mapTypeRef, planOperation, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, walkTypeRef } from "@workos/oagen";
 //#region src/node/naming.ts
 /** kebab-case file name (without extension). */
@@ -45,9 +47,84 @@ function buildServiceNameMap(services, ctx) {
 	for (const service of services) map.set(service.name, resolveServiceName(service, ctx));
 	return map;
 }
+/**
+* Explicit method name overrides for operations where the spec's operationId
+* does not match the desired SDK method name and the spec cannot be changed.
+* Key: "HTTP_METHOD /path", Value: camelCase method name.
+*/
+const METHOD_NAME_OVERRIDES = { "POST /portal/generate_link": "generatePortalLink" };
+/**
+* Explicit service directory overrides. Maps a resolved PascalCase service name
+* to a target directory (kebab-case). Use this when the spec's tag grouping
+* does not match the desired SDK directory layout and the spec cannot be changed.
+*/
+const SERVICE_DIR_OVERRIDES = {
+	ApplicationClientSecrets: "workos-connect",
+	Applications: "workos-connect",
+	Connections: "sso",
+	Directories: "directory-sync",
+	DirectoryGroups: "directory-sync",
+	DirectoryUsers: "directory-sync",
+	FeatureFlagsTargets: "feature-flags",
+	MultiFactorAuth: "mfa",
+	MultiFactorAuthChallenges: "mfa",
+	OrganizationsApiKeys: "organizations",
+	WebhooksEndpoints: "webhooks",
+	UserManagementAuthentication: "user-management",
+	UserManagementCorsOrigins: "user-management",
+	UserManagementDataProviders: "user-management",
+	UserManagementInvitations: "user-management",
+	UserManagementJWTTemplate: "user-management",
+	UserManagementMagicAuth: "user-management",
+	UserManagementMultiFactorAuthentication: "user-management",
+	UserManagementOrganizationMembership: "user-management",
+	UserManagementRedirectUris: "user-management",
+	UserManagementSessionTokens: "user-management",
+	UserManagementUsers: "user-management",
+	UserManagementUsersAuthorizedApplications: "user-management",
+	WorkOSConnect: "workos-connect"
+};
+/**
+* Maps a service (by PascalCase name) to the existing hand-written class that
+* already covers its endpoints. When a service appears here:
+*   - `resolveClassName` returns the target class (so generated code merges in)
+*   - `isServiceCoveredByExisting` returns true
+*   - `hasMethodsAbsentFromBaseline` checks the target class for missing methods,
+*     so new endpoints are added to the existing class rather than silently dropped
+*/
+const SERVICE_COVERED_BY = {
+	Connections: "SSO",
+	Directories: "DirectorySync",
+	DirectoryGroups: "DirectorySync",
+	DirectoryUsers: "DirectorySync",
+	FeatureFlagsTargets: "FeatureFlags",
+	MultiFactorAuth: "Mfa",
+	MultiFactorAuthChallenges: "Mfa",
+	OrganizationsApiKeys: "Organizations",
+	UserManagementAuthentication: "UserManagement",
+	UserManagementInvitations: "UserManagement",
+	UserManagementMagicAuth: "UserManagement",
+	UserManagementMultiFactorAuthentication: "UserManagement",
+	UserManagementOrganizationMembership: "UserManagement",
+	UserManagementUsers: "UserManagement"
+};
+/**
+* Explicit class name overrides. Maps the default PascalCase service name
+* to the desired SDK class name when toPascalCase produces the wrong casing.
+*/
+const CLASS_NAME_OVERRIDES = { WorkosConnect: "WorkOSConnect" };
+/**
+* Resolve the output directory for a service, checking overrides first.
+* Falls back to the standard kebab-case conversion.
+*/
+function resolveServiceDir(resolvedServiceName) {
+	return SERVICE_DIR_OVERRIDES[resolvedServiceName] ?? serviceDirName(resolvedServiceName);
+}
 /** Resolve the SDK method name for an operation, checking overlay first. */
 function resolveMethodName(op, _service, ctx) {
 	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+	const override = METHOD_NAME_OVERRIDES[httpKey];
+	if (override) return override;
 	const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
 	if (existing) {
 		if (/\/\{[^}]+\}$/.test(op.path) && existing.methodName.endsWith("s") && !existing.methodName.endsWith("ss")) {
@@ -61,12 +138,15 @@ function resolveMethodName(op, _service, ctx) {
 }
 /** Resolve the SDK class name for a service, checking overlay for existing names. */
 function resolveClassName(service, ctx) {
+	const coveredBy = SERVICE_COVERED_BY[toPascalCase(service.name)];
+	if (coveredBy) return coveredBy;
 	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;
+		if (existing) return CLASS_NAME_OVERRIDES[existing.className] ?? existing.className;
 	}
-	return toPascalCase(service.name);
+	const defaultName = toPascalCase(service.name);
+	return CLASS_NAME_OVERRIDES[defaultName] ?? defaultName;
 }
 /** Resolve the interface name for a model, checking overlay first. */
 function resolveInterfaceName(name, ctx) {
@@ -330,7 +410,7 @@ function buildKnownTypeNames(models, ctx) {
 function createServiceDirResolver(models, services, ctx) {
 	const modelToService = assignModelsToServices(models, services);
 	const serviceNameMap = buildServiceNameMap(services, ctx);
-	const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
+	const resolveDir = (irService) => irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : "common";
 	return {
 		modelToService,
 		serviceNameMap,
@@ -458,6 +538,7 @@ function buildDeduplicationMap(models, ctx) {
 * endpoints (e.g., `GET /connections`).
 */
 function isServiceCoveredByExisting(service, ctx) {
+	if (SERVICE_COVERED_BY[toPascalCase(service.name)]) return true;
 	const overlay = ctx.overlayLookup?.methodByOperation;
 	if (!overlay || overlay.size === 0) return false;
 	if (service.operations.length === 0) return false;
@@ -472,6 +553,37 @@ function isServiceCoveredByExisting(service, ctx) {
 	});
 }
 /**
+* Check whether a fully-covered service has operations whose overlay-mapped
+* methods are missing from the baseline class.  Returns true when at least
+* one operation maps to a method name that the baseline class does not have,
+* meaning the merger needs to add new methods (skipIfExists must be removed).
+*/
+function hasMethodsAbsentFromBaseline(service, ctx) {
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return false;
+	const targetClassName = SERVICE_COVERED_BY[toPascalCase(service.name)];
+	if (targetClassName) {
+		const cls = baselineClasses[targetClassName];
+		if (!cls) return true;
+		for (const op of service.operations) {
+			const method = resolveMethodName(op, service, ctx);
+			if (!cls.methods?.[method]) return true;
+		}
+		return false;
+	}
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay) return false;
+	for (const op of service.operations) {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) continue;
+		const cls = baselineClasses[match.className];
+		if (!cls) continue;
+		if (!cls.methods?.[match.methodName]) return true;
+	}
+	return false;
+}
+/**
 * Return operations in a service that are NOT covered by existing hand-written
 * service classes. For fully uncovered services, returns all operations.
 * For partially covered services, returns only the uncovered operations.
@@ -495,7 +607,7 @@ function generateEnums(enums, ctx) {
 	if (enums.length === 0) return [];
 	const enumToService = assignEnumsToServices(enums, ctx.spec.services);
 	const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
-	const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
+	const resolveDir = (irService) => irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : "common";
 	const files = [];
 	for (const enumDef of enums) {
 		const dirName = resolveDir(enumToService.get(enumDef.name));
@@ -513,7 +625,7 @@ function generateEnums(enums, ctx) {
 				lines.push(`  ${memberName} = ${valueStr},`);
 			}
 			for (const val of missingValues) {
-				const memberName = val.replace(/[^a-zA-Z0-9]+/g, "");
+				const memberName = toPascalCase(val);
 				lines.push(`  ${memberName} = '${val}',`);
 			}
 			lines.push("}");
@@ -725,54 +837,60 @@ function generateModels(models, ctx) {
 		const typeParams = renderTypeParams(model, genericDefaults);
 		const seenDomainFields = /* @__PURE__ */ new Set();
 		if (model.description) lines.push(...docComment(model.description));
-		lines.push(`export interface ${domainName}${typeParams} {`);
-		for (const field of model.fields) {
-			const domainFieldName = fieldName(field.name);
-			if (seenDomainFields.has(domainFieldName)) continue;
-			seenDomainFields.add(domainFieldName);
-			if (field.description || field.deprecated || field.readOnly || field.writeOnly || field.default !== void 0) {
-				const parts = [];
-				if (field.description) parts.push(field.description);
-				if (field.readOnly) parts.push("@readonly");
-				if (field.writeOnly) parts.push("@writeonly");
-				if (field.default !== void 0) parts.push(`@default ${JSON.stringify(field.default)}`);
-				if (field.deprecated) parts.push("@deprecated");
-				lines.push(...docComment(parts.join("\n"), 2));
-			}
-			const baselineField = baselineDomain?.fields?.[domainFieldName];
-			const domainWireField = wireFieldName(field.name);
-			const responseBaselineField = baselineResponse?.fields?.[domainWireField];
-			const domainResponseOptionalMismatch = baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
-			const readonlyPrefix = field.readOnly ? "readonly " : "";
-			if (baselineField && !domainResponseOptionalMismatch && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
-				const opt = baselineField.optional ? "?" : "";
-				lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${baselineField.type};`);
-			} else {
-				const isNewFieldOnExistingModel = baselineDomain && !baselineField;
-				const isNewFieldOnExistingResponse = !baselineDomain && baselineResponse && !responseBaselineField;
-				const opt = !field.required || isNewFieldOnExistingModel || domainResponseOptionalMismatch || isNewFieldOnExistingResponse ? "?" : "";
-				lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${mapTypeRef$1(field.type, modelTypeRefOpts)};`);
+		if (model.fields.length === 0) lines.push(`export type ${domainName}${typeParams} = object;`);
+		else {
+			lines.push(`export interface ${domainName}${typeParams} {`);
+			for (const field of model.fields) {
+				const domainFieldName = fieldName(field.name);
+				if (seenDomainFields.has(domainFieldName)) continue;
+				seenDomainFields.add(domainFieldName);
+				if (field.description || field.deprecated || field.readOnly || field.writeOnly || field.default !== void 0) {
+					const parts = [];
+					if (field.description) parts.push(field.description);
+					if (field.readOnly) parts.push("@readonly");
+					if (field.writeOnly) parts.push("@writeonly");
+					if (field.default !== void 0) parts.push(`@default ${JSON.stringify(field.default)}`);
+					if (field.deprecated) parts.push("@deprecated");
+					lines.push(...docComment(parts.join("\n"), 2));
+				}
+				const baselineField = baselineDomain?.fields?.[domainFieldName];
+				const domainWireField = wireFieldName(field.name);
+				const responseBaselineField = baselineResponse?.fields?.[domainWireField];
+				const domainResponseOptionalMismatch = baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
+				const readonlyPrefix = field.readOnly ? "readonly " : "";
+				if (baselineField && !domainResponseOptionalMismatch && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
+					const opt = baselineField.optional ? "?" : "";
+					lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${baselineField.type};`);
+				} else {
+					const isNewFieldOnExistingModel = baselineDomain && !baselineField;
+					const isNewFieldOnExistingResponse = !baselineDomain && baselineResponse && !responseBaselineField;
+					const opt = !field.required || isNewFieldOnExistingModel || domainResponseOptionalMismatch || isNewFieldOnExistingResponse ? "?" : "";
+					lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${mapTypeRef$1(field.type, modelTypeRefOpts)};`);
+				}
 			}
+			lines.push("}");
 		}
-		lines.push("}");
 		lines.push("");
 		const seenWireFields = /* @__PURE__ */ new Set();
-		lines.push(`export interface ${responseName}${typeParams} {`);
-		for (const field of model.fields) {
-			const wireField = wireFieldName(field.name);
-			if (seenWireFields.has(wireField)) continue;
-			seenWireFields.add(wireField);
-			const baselineField = baselineResponse?.fields?.[wireField];
-			if (baselineField && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
-				const opt = baselineField.optional ? "?" : "";
-				lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
-			} else {
-				const isNewFieldOnExistingModel = baselineResponse && !baselineField;
-				const opt = !field.required || isNewFieldOnExistingModel ? "?" : "";
-				lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+		if (model.fields.length === 0) lines.push(`export type ${responseName}${typeParams} = object;`);
+		else {
+			lines.push(`export interface ${responseName}${typeParams} {`);
+			for (const field of model.fields) {
+				const wireField = wireFieldName(field.name);
+				if (seenWireFields.has(wireField)) continue;
+				seenWireFields.add(wireField);
+				const baselineField = baselineResponse?.fields?.[wireField];
+				if (baselineField && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
+					const opt = baselineField.optional ? "?" : "";
+					lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
+				} else {
+					const isNewFieldOnExistingModel = baselineResponse && !baselineField;
+					const opt = !field.required || isNewFieldOnExistingModel ? "?" : "";
+					lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+				}
 			}
+			lines.push("}");
 		}
-		lines.push("}");
 		files.push({
 			path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
 			content: pruneUnusedImports(lines).join("\n"),
@@ -1280,7 +1398,7 @@ function generateFixtures(spec, ctx) {
 	if (spec.models.length === 0) return [];
 	const { modelToService, resolveDir } = ctx ? createServiceDirResolver(spec.models, ctx.spec.services, ctx) : {
 		modelToService: assignModelsToServices$1(spec.models, spec.services),
-		resolveDir: (irService) => irService ? serviceDirName(irService) : "common"
+		resolveDir: (irService) => irService ? resolveServiceDir(irService) : "common"
 	};
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -1296,7 +1414,7 @@ function generateFixtures(spec, ctx) {
 		});
 	}
 	for (const service of spec.services) {
-		const serviceDir = serviceDirName(ctx ? resolveResourceClassName(service, ctx) : service.name);
+		const serviceDir = resolveServiceDir(ctx ? resolveResourceClassName(service, ctx) : service.name);
 		for (const op of service.operations) if (op.pagination) {
 			let itemModel = op.pagination.itemType.kind === "model" ? modelMap.get(op.pagination.itemType.name) : null;
 			if (itemModel) {
@@ -1444,18 +1562,261 @@ function paginatedOptionsName(method, resolvedServiceName) {
 function httpMethodNeedsBody(method) {
 	return method === "post" || method === "put" || method === "patch";
 }
+/** Map HTTP methods to expected CRUD verb prefixes for method name matching. */
+const HTTP_VERB_PREFIXES = {
+	get: [
+		"list",
+		"get",
+		"fetch",
+		"retrieve",
+		"find"
+	],
+	post: [
+		"create",
+		"add",
+		"insert",
+		"send"
+	],
+	put: [
+		"set",
+		"update",
+		"replace",
+		"put"
+	],
+	patch: [
+		"update",
+		"patch",
+		"modify"
+	],
+	delete: [
+		"delete",
+		"remove",
+		"revoke"
+	]
+};
+/** Split a camelCase/PascalCase name into lowercase word parts. */
+function splitCamelWords(name) {
+	const parts = [];
+	let start = 0;
+	for (let i = 1; i < name.length; i++) if (name[i] >= "A" && name[i] <= "Z") {
+		parts.push(name.slice(start, i).toLowerCase());
+		start = i;
+	}
+	parts.push(name.slice(start).toLowerCase());
+	return parts;
+}
+/** Naive singularize: strip trailing 's' unless it ends in 'ss'. */
+function singularize(word) {
+	return word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word;
+}
+/**
+* Batch-reconcile generated method names against the api-surface class methods.
+*
+* When the overlay doesn't map an operation (missing from previous manifest or
+* fuzzy-matching failed), the emitter falls back to the spec-derived name which
+* often doesn't match the hand-written SDK. This function uses three passes
+* with progressive exclusion to find the best surface match:
+*
+* 1. **Overlay-resolved** — already correct, mark as taken.
+* 2. **Word-set match** — same content words regardless of order (handles
+*    `listRolesOrganizations` ↔ `listOrganizationRoles`).
+* 3. **Path-context match** — all surface-method content words appear in the
+*    operation's URL path segments (handles `findById` ↔ `getResource`).
+*
+* After each pass, matched surface methods are removed from the pool so that
+* ambiguous cases (e.g., `listEnvironmentRoles` vs `listOrganizationRoles`)
+* resolve by elimination.
+*/
+function reconcileMethodNames(plans, service, ctx) {
+	const className = resolveResourceClassName(service, ctx);
+	const classMethods = ctx.apiSurface?.classes?.[className]?.methods;
+	if (!classMethods) return;
+	const available = new Set(Object.keys(classMethods));
+	const resolved = /* @__PURE__ */ new Map();
+	const thisServicePaths = new Set(service.operations.map((op) => op.path));
+	if (ctx.overlayLookup?.methodByOperation) for (const [httpKey, info] of ctx.overlayLookup.methodByOperation) {
+		if (info.className !== className) continue;
+		const path = httpKey.split(" ")[1];
+		if (thisServicePaths.has(path)) continue;
+		available.delete(info.methodName);
+	}
+	const overlayResolved = /* @__PURE__ */ new Set();
+	for (const plan of plans) {
+		const httpKey = `${plan.op.httpMethod.toUpperCase()} ${plan.op.path}`;
+		if (ctx.overlayLookup?.methodByOperation?.get(httpKey)) {
+			overlayResolved.add(plan);
+			if (available.has(plan.method)) {
+				resolved.set(plan, plan.method);
+				available.delete(plan.method);
+			}
+		}
+	}
+	const verbMatches = (methodName, httpMethod, specVerb) => {
+		const prefixes = HTTP_VERB_PREFIXES[httpMethod] ?? [];
+		const lower = methodName.toLowerCase();
+		if (!prefixes.some((p) => lower.startsWith(p))) return false;
+		if (specVerb) {
+			const surfaceVerb = splitCamelWords(methodName)[0];
+			if (specVerb === "list" && surfaceVerb !== "list") return false;
+			if (specVerb !== "list" && surfaceVerb === "list") return false;
+		}
+		return true;
+	};
+	for (const plan of plans) {
+		if (resolved.has(plan)) continue;
+		const specVerb = splitCamelWords(plan.method)[0];
+		const specWords = splitCamelWords(plan.method).slice(1).map(singularize);
+		const specSet = new Set(specWords);
+		if (specSet.size === 0) continue;
+		let match = null;
+		for (const name of available) {
+			if (!verbMatches(name, plan.op.httpMethod, specVerb)) continue;
+			const methodWords = splitCamelWords(name).slice(1).map(singularize);
+			if (methodWords.length !== specWords.length) continue;
+			const methodSet = new Set(methodWords);
+			if (specSet.size === methodSet.size && [...specSet].every((w) => methodSet.has(w))) {
+				if (match !== null) {
+					match = null;
+					break;
+				}
+				match = name;
+			}
+		}
+		if (match) {
+			resolved.set(plan, match);
+			available.delete(match);
+		}
+	}
+	for (const plan of plans) {
+		if (resolved.has(plan)) continue;
+		const specVerb = splitCamelWords(plan.method)[0];
+		const pathSegments = plan.op.path.split("/").filter((s) => s && !s.startsWith("{"));
+		const pathWords = new Set(pathSegments.flatMap((s) => s.split("_")).map(singularize));
+		let bestMatch = null;
+		let bestLen = 0;
+		let ambiguous = false;
+		for (const name of available) {
+			if (!verbMatches(name, plan.op.httpMethod, specVerb)) continue;
+			const methodWords = splitCamelWords(name).slice(1).map(singularize);
+			if (methodWords.length === 0) continue;
+			if (!methodWords.every((w) => pathWords.has(w))) continue;
+			if (methodWords.length < 2 && pathSegments.length > 2) continue;
+			if (methodWords.length > bestLen) {
+				bestMatch = name;
+				bestLen = methodWords.length;
+				ambiguous = false;
+			} else if (methodWords.length === bestLen) ambiguous = true;
+		}
+		if (bestMatch && !ambiguous) {
+			resolved.set(plan, bestMatch);
+			available.delete(bestMatch);
+		}
+	}
+	for (const plan of plans) {
+		if (resolved.has(plan)) continue;
+		const specVerb = splitCamelWords(plan.method)[0];
+		const specWords = splitCamelWords(plan.method).slice(1).map(singularize);
+		const specSet = new Set(specWords);
+		let match = null;
+		for (const name of available) {
+			if (!verbMatches(name, plan.op.httpMethod, specVerb)) continue;
+			const methodWords = splitCamelWords(name).slice(1).map(singularize);
+			if (methodWords.length !== specWords.length) continue;
+			const methodSet = new Set(methodWords);
+			if (specSet.size === methodSet.size && [...specSet].every((w) => methodSet.has(w))) {
+				if (match !== null) {
+					match = null;
+					break;
+				}
+				match = name;
+			}
+		}
+		if (match) {
+			resolved.set(plan, match);
+			available.delete(match);
+			continue;
+		}
+		const pathSegments = plan.op.path.split("/").filter((s) => s && !s.startsWith("{"));
+		const pathWords = new Set(pathSegments.flatMap((s) => s.split("_")).map(singularize));
+		let bestMatch = null;
+		let bestLen = 0;
+		let ambiguous = false;
+		for (const name of available) {
+			if (!verbMatches(name, plan.op.httpMethod, specVerb)) continue;
+			const methodWords = splitCamelWords(name).slice(1).map(singularize);
+			if (methodWords.length === 0) continue;
+			if (!methodWords.every((w) => pathWords.has(w))) continue;
+			if (methodWords.length < 2 && pathSegments.length > 2) continue;
+			if (methodWords.length > bestLen) {
+				bestMatch = name;
+				bestLen = methodWords.length;
+				ambiguous = false;
+			} else if (methodWords.length === bestLen) ambiguous = true;
+		}
+		if (bestMatch && !ambiguous) {
+			resolved.set(plan, bestMatch);
+			available.delete(bestMatch);
+		}
+	}
+	for (const plan of plans) {
+		if (overlayResolved.has(plan)) continue;
+		const name = resolved.get(plan);
+		if (name) plan.method = name;
+	}
+}
+/**
+* Deduplicate method names within the plans array.
+*
+* When `disambiguateOperationNames()` in `@workos/oagen` fails (e.g., for
+* single-segment paths like `/organizations`), two operations can resolve to
+* the same method name. Disambiguate by appending a path-derived suffix.
+*/
+function deduplicateMethodNames(plans, _ctx) {
+	const nameCount = /* @__PURE__ */ new Map();
+	for (const p of plans) nameCount.set(p.method, (nameCount.get(p.method) ?? 0) + 1);
+	for (const [name, count] of nameCount) {
+		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));
+		const scored = dupes.map((d) => {
+			return {
+				plan: d,
+				score: d.op.path.split("/").filter((s) => s && !s.startsWith("{")).flatMap((s) => s.split("_")).map(singularize).filter((w) => nameWords.has(w)).length
+			};
+		});
+		scored.sort((a, b) => b.score - a.score);
+		for (let i = 1; i < scored.length; i++) {
+			const dupe = scored[i].plan;
+			const suffix = dupe.op.path.split("/").filter((s) => s && !s.startsWith("{"))[0] ?? "";
+			if (suffix) dupe.method = toCamelCase(`${name}_${suffix}`);
+		}
+		const stillDuped = /* @__PURE__ */ new Map();
+		for (const dupe of dupes) {
+			const group = stillDuped.get(dupe.method) ?? [];
+			group.push(dupe);
+			stillDuped.set(dupe.method, group);
+		}
+		for (const [, group] of stillDuped) {
+			if (group.length <= 1) continue;
+			for (let i = 1; i < group.length; i++) group[i].method = `${group[i].method}${i + 1}`;
+		}
+	}
+}
 function generateResources(services, ctx) {
 	if (services.length === 0) return [];
 	const files = [];
 	for (const service of services) {
-		if (isServiceCoveredByExisting(service, ctx)) continue;
+		if (isServiceCoveredByExisting(service, ctx)) {
+			const file = generateResourceClass(service, ctx);
+			if (hasMethodsAbsentFromBaseline(service, ctx)) delete file.skipIfExists;
+			files.push(file);
+			continue;
+		}
 		const ops = uncoveredOperations(service, ctx);
 		if (ops.length === 0) continue;
 		if (ops.length < service.operations.length) {
-			const file = generateResourceClass({
-				...service,
-				operations: ops
-			}, ctx);
+			const file = generateResourceClass(service, ctx);
 			delete file.skipIfExists;
 			files.push(file);
 		} else files.push(generateResourceClass(service, ctx));
@@ -1464,7 +1825,7 @@ function generateResources(services, ctx) {
 }
 function generateResourceClass(service, ctx) {
 	const resolvedName = resolveResourceClassName(service, ctx);
-	const serviceDir = serviceDirName(resolvedName);
+	const serviceDir = resolveServiceDir(resolvedName);
 	const serviceClass = resolvedName;
 	const resourcePath = `src/${serviceDir}/${fileName(resolvedName)}.ts`;
 	const plans = service.operations.map((op) => ({
@@ -1472,6 +1833,8 @@ function generateResourceClass(service, ctx) {
 		plan: planOperation(op),
 		method: resolveMethodName(op, service, ctx)
 	}));
+	reconcileMethodNames(plans, service, ctx);
+	deduplicateMethodNames(plans, ctx);
 	if (ctx.overlayLookup?.methodByOperation) {
 		const methodOrder = /* @__PURE__ */ new Map();
 		let pos = 0;
@@ -1499,7 +1862,7 @@ function generateResourceClass(service, ctx) {
 		const bodyInfo = extractRequestBodyType(op, ctx);
 		if (bodyInfo?.kind === "model") requestModels.add(bodyInfo.name);
 		else if (bodyInfo?.kind === "union") if (bodyInfo.discriminator) for (const name of bodyInfo.modelNames) requestModels.add(name);
-		else for (const name of bodyInfo.modelNames) paramModels.add(name);
+		else for (const name of bodyInfo.modelNames) requestModels.add(name);
 		const queryParams = plan.isPaginated ? op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name)) : op.queryParams;
 		for (const param of [...queryParams, ...op.pathParams]) collectParamTypeRefs(param.type, paramEnums, paramModels);
 	}
@@ -1744,7 +2107,7 @@ function renderDeleteWithBodyMethod(lines, op, plan, method, pathStr, ctx, specE
 	} else if (bodyInfo?.kind === "union") {
 		requestType = bodyInfo.typeStr;
 		if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
-		else bodyExpr = "payload";
+		else bodyExpr = renderNonDiscriminatedUnionBodySerializer(bodyInfo.modelNames, ctx);
 	} else {
 		requestType = "Record<string, unknown>";
 		bodyExpr = "payload";
@@ -1766,7 +2129,7 @@ function renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx,
 	} else if (bodyInfo?.kind === "union") {
 		requestType = bodyInfo.typeStr;
 		if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
-		else bodyExpr = "payload";
+		else bodyExpr = renderNonDiscriminatedUnionBodySerializer(bodyInfo.modelNames, ctx);
 	} else {
 		requestType = "Record<string, unknown>";
 		bodyExpr = "payload";
@@ -1839,7 +2202,7 @@ function renderVoidMethod(lines, op, plan, method, pathStr, ctx, specEnumNames)
 		} else if (bodyInfo?.kind === "union") {
 			bodyParam = `payload: ${bodyInfo.typeStr}`;
 			if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
-			else bodyExpr = "payload";
+			else bodyExpr = renderNonDiscriminatedUnionBodySerializer(bodyInfo.modelNames, ctx);
 		} else {
 			bodyParam = "payload: Record<string, unknown>";
 			bodyExpr = "payload";
@@ -1930,6 +2293,90 @@ function renderUnionBodySerializer(disc, ctx) {
 	}
 	return `(() => { switch ((payload as any).${prop}) { ${cases.join("; ")}; default: return payload } })()`;
 }
+/**
+* Generate an IIFE expression that dispatches to the correct serializer for a
+* non-discriminated union request body.  Inspects model fields to find a
+* required field unique to each variant and uses `'field' in payload` guards.
+* Falls back to `payload` only when no variant can be distinguished.
+*/
+function renderNonDiscriminatedUnionBodySerializer(modelNames, ctx) {
+	const modelMap = new Map(ctx.spec.models.map((m) => [m.name, m]));
+	const implicitDisc = detectImplicitDiscriminator(modelNames, modelMap);
+	if (implicitDisc) return renderUnionBodySerializer(implicitDisc, ctx);
+	const requiredFieldsByModel = /* @__PURE__ */ new Map();
+	for (const name of modelNames) {
+		const model = modelMap.get(name);
+		if (!model) return "payload";
+		requiredFieldsByModel.set(name, new Set(model.fields.filter((f) => f.required).map((f) => fieldName(f.name))));
+	}
+	const guards = [];
+	let fallbackModel;
+	for (const name of modelNames) {
+		const myFields = requiredFieldsByModel.get(name);
+		let uniqueField;
+		for (const field of myFields) if (modelNames.every((other) => other === name || !requiredFieldsByModel.get(other)?.has(field))) {
+			uniqueField = field;
+			break;
+		}
+		if (uniqueField) guards.push({
+			modelName: name,
+			field: uniqueField
+		});
+		else if (!fallbackModel) fallbackModel = name;
+		else return "payload";
+	}
+	if (guards.length === 0) return "payload";
+	const parts = [];
+	for (const { modelName, field } of guards) {
+		const resolved = resolveInterfaceName(modelName, ctx);
+		parts.push(`if ('${field}' in payload) return serialize${resolved}(payload as any)`);
+	}
+	if (fallbackModel) {
+		const resolved = resolveInterfaceName(fallbackModel, ctx);
+		parts.push(`return serialize${resolved}(payload as any)`);
+	} else parts.push("return payload");
+	return `(() => { ${parts.join("; ")} })()`;
+}
+/**
+* Detect an implicit discriminator from literal-typed fields.
+* Returns a discriminator descriptor if all variants share a required field
+* whose type is `kind: 'literal'` with a distinct value per variant.
+*/
+function detectImplicitDiscriminator(modelNames, modelMap) {
+	if (modelNames.length < 2) return null;
+	const firstModel = modelMap.get(modelNames[0]);
+	if (!firstModel) return null;
+	const candidates = firstModel.fields.filter((f) => f.required && f.type.kind === "literal");
+	for (const candidate of candidates) {
+		const mapping = {};
+		const values = /* @__PURE__ */ new Set();
+		let valid = true;
+		for (const name of modelNames) {
+			const model = modelMap.get(name);
+			if (!model) {
+				valid = false;
+				break;
+			}
+			const field = model.fields.find((f) => f.name === candidate.name);
+			if (!field || !field.required || field.type.kind !== "literal") {
+				valid = false;
+				break;
+			}
+			const val = field.type.value;
+			if (values.has(val)) {
+				valid = false;
+				break;
+			}
+			values.add(val);
+			mapping[String(val)] = name;
+		}
+		if (valid && Object.keys(mapping).length === modelNames.length) return {
+			property: candidate.name,
+			mapping
+		};
+	}
+	return null;
+}
 function extractRequestBodyType(op, ctx) {
 	if (!op.requestBody) return null;
 	if (op.requestBody.kind === "model") return {
@@ -1989,7 +2436,7 @@ function generateWorkOSClient(spec, ctx) {
 	for (const service of spec.services) {
 		if (coveredServices.has(service.name)) continue;
 		const resolvedName = resolveResourceClassName(service, ctx);
-		const serviceDir = serviceDirName(resolvedName);
+		const serviceDir = resolveServiceDir(resolvedName);
 		lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
 	}
 	lines.push("");
@@ -2139,9 +2586,52 @@ function generateBarrel(spec, ctx) {
 	const coveredServicesBarrel = /* @__PURE__ */ new Set();
 	for (const service of spec.services) if (isServiceCoveredByExisting(service, ctx)) coveredServicesBarrel.add(service.name);
 	const exportedDirs = /* @__PURE__ */ new Set();
+	const dirAllNames = /* @__PURE__ */ new Map();
+	for (const service of spec.services) {
+		const iDir = resolveDir(service.name);
+		if (!dirAllNames.has(iDir)) dirAllNames.set(iDir, /* @__PURE__ */ new Set());
+		const names = dirAllNames.get(iDir);
+		for (const model of spec.models) {
+			if (modelToService.get(model.name) !== service.name) continue;
+			if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
+			names.add(resolveInterfaceName(model.name, ctx));
+			names.add(wireInterfaceName(resolveInterfaceName(model.name, ctx)));
+		}
+	}
+	if (ctx.apiSurface?.interfaces) for (const [name, iface] of Object.entries(ctx.apiSurface.interfaces)) {
+		const sourceFile = iface.sourceFile;
+		if (!sourceFile) continue;
+		const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
+		if (match) {
+			const dirName = match[1];
+			if (!dirAllNames.has(dirName)) dirAllNames.set(dirName, /* @__PURE__ */ new Set());
+			dirAllNames.get(dirName).add(name);
+		}
+	}
+	if (ctx.apiSurface?.typeAliases) for (const [name, alias] of Object.entries(ctx.apiSurface.typeAliases)) {
+		const sourceFile = alias.sourceFile;
+		if (!sourceFile) continue;
+		const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
+		if (match) {
+			const dirName = match[1];
+			if (!dirAllNames.has(dirName)) dirAllNames.set(dirName, /* @__PURE__ */ new Set());
+			dirAllNames.get(dirName).add(name);
+		}
+	}
+	const unsafeStarDirs = /* @__PURE__ */ new Set();
+	const allDirEntries = [...dirAllNames.entries()];
+	for (let i = 0; i < allDirEntries.length; i++) for (let j = i + 1; j < allDirEntries.length; j++) {
+		const [dirA, namesA] = allDirEntries[i];
+		const [dirB, namesB] = allDirEntries[j];
+		for (const name of namesA) if (namesB.has(name)) {
+			unsafeStarDirs.add(dirA);
+			unsafeStarDirs.add(dirB);
+			break;
+		}
+	}
 	for (const service of spec.services) {
 		const resolvedName = resolveResourceClassName(service, ctx);
-		const serviceDir = serviceDirName(resolvedName);
+		const serviceDir = resolveServiceDir(resolvedName);
 		const interfacesDir = resolveDir(service.name);
 		const serviceModels = spec.models.filter((m) => {
 			if (modelToService.get(m.name) !== service.name) return false;
@@ -2151,8 +2641,12 @@ function generateBarrel(spec, ctx) {
 		const serviceEnums = spec.enums.filter((e) => {
 			return findEnumService(e.name, spec.services) === service.name;
 		});
-		const hasConflict = serviceModels.some((m) => existingSdkExports.has(resolveInterfaceName(m.name, ctx))) || serviceEnums.some((e) => existingSdkExports.has(e.name));
-		if ((serviceModels.length > 0 || serviceEnums.length > 0) && !exportedDirs.has(interfacesDir) && !hasConflict) {
+		const hasConflict = serviceModels.some((m) => {
+			const name = resolveInterfaceName(m.name, ctx);
+			return existingSdkExports.has(name) || exportedNames.has(name) || exportedNames.has(wireInterfaceName(name));
+		}) || serviceEnums.some((e) => existingSdkExports.has(e.name) || exportedNames.has(e.name));
+		const isCovered = coveredServicesBarrel.has(service.name);
+		if ((serviceModels.length > 0 || serviceEnums.length > 0) && !exportedDirs.has(interfacesDir) && !hasConflict && !unsafeStarDirs.has(interfacesDir) && !isCovered) {
 			exportedDirs.add(interfacesDir);
 			lines.push(`export * from './${interfacesDir}/interfaces';`);
 			for (const model of serviceModels) {
@@ -2887,7 +3381,7 @@ export function fetchBody({ raw = false } = {}): any {
 export function testUnauthorized(fn: () => Promise<any>) {
   it('throws on unauthorized', async () => {
     fetchOnce({ message: 'Unauthorized' }, { status: 401 });
-    await expect(fn()).rejects.toThrow('Unauthorized');
+    await expect(fn()).rejects.toThrow('Could not authorize the request');
   });
 }
 
@@ -2941,7 +3435,8 @@ function generateTests(spec, ctx) {
 	for (const f of fixtures) files.push({
 		path: f.path,
 		content: f.content,
-		headerPlacement: "skip"
+		headerPlacement: "skip",
+		integrateTarget: false
 	});
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	for (const service of spec.services) {
@@ -2960,7 +3455,7 @@ function generateTests(spec, ctx) {
 }
 function generateServiceTest(service, spec, ctx, modelMap) {
 	const resolvedName = resolveResourceClassName(service, ctx);
-	const serviceDir = serviceDirName(resolvedName);
+	const serviceDir = resolveServiceDir(resolvedName);
 	const serviceClass = resolvedName;
 	const serviceProp = servicePropertyName(resolvedName);
 	const testPath = `src/${serviceDir}/${fileName(resolvedName)}.spec.ts`;
@@ -3219,8 +3714,9 @@ function buildCallArgs(op, plan, modelMap) {
 	const hasBody = plan.hasBody;
 	if (isPaginated) return pathArgs || "";
 	if (hasBody) {
-		const fb = fallbackBodyArg(op, modelMap);
-		return pathArgs ? `${pathArgs}, ${fb}` : fb;
+		const payload = buildTestPayload(op, modelMap);
+		const bodyArg = payload ? payload.camelCaseObj : fallbackBodyArg(op, modelMap);
+		return pathArgs ? `${pathArgs}, ${bodyArg}` : bodyArg;
 	}
 	return pathArgs || "";
 }
@@ -3307,10 +3803,12 @@ function buildFieldAssertions(model, accessor, modelMap) {
 	return assertions;
 }
 /**
-* Return a JS literal string for the expected fixture value of a primitive field.
-* Returns null for non-primitive or complex types (arrays, models, etc.).
+* Return a JS literal string for the expected fixture value of a field.
+* Returns null for types that cannot be deterministically generated.
+* When a modelMap is provided, recursively builds object literals for nested model types.
+* When wire is true, uses snake_case keys for nested model objects (wire format).
 */
-function fixtureValueForType(ref, name, modelName) {
+function fixtureValueForType(ref, name, modelName, modelMap, wire) {
 	switch (ref.kind) {
 		case "primitive": return fixtureValueForPrimitive(ref.type, ref.format, name, modelName);
 		case "literal": return typeof ref.value === "string" ? `'${ref.value}'` : String(ref.value);
@@ -3321,10 +3819,24 @@ function fixtureValueForType(ref, name, modelName) {
 			}
 			return null;
 		case "array": {
-			const itemValue = fixtureValueForType(ref.items, name, modelName);
+			const itemValue = fixtureValueForType(ref.items, name, modelName, modelMap, wire);
 			if (itemValue !== null) return `[${itemValue}]`;
 			return null;
 		}
+		case "model": {
+			if (!modelMap) return null;
+			const nested = modelMap.get(ref.name);
+			if (!nested) return null;
+			const requiredFields = nested.fields.filter((f) => f.required);
+			const entries = [];
+			for (const field of requiredFields) {
+				const value = fixtureValueForType(field.type, field.name, nested.name, modelMap, wire);
+				if (value === null) return null;
+				const key = wire ? wireFieldName(field.name) : fieldName(field.name);
+				entries.push(`${key}: ${value}`);
+			}
+			return `{ ${entries.join(", ")} }`;
+		}
 		default: return null;
 	}
 }
@@ -3368,16 +3880,17 @@ function buildTestPayload(op, modelMap) {
 	const model = modelMap.get(op.requestBody.name);
 	if (!model) return null;
 	const fields = model.fields.filter((f) => f.required);
-	const usableFields = fields.filter((f) => fixtureValueForType(f.type, f.name, model.name) !== null);
+	const usableFields = fields.filter((f) => fixtureValueForType(f.type, f.name, model.name, modelMap) !== null);
 	if (usableFields.length === 0 || usableFields.length < fields.length) return null;
 	const camelEntries = [];
 	const snakeEntries = [];
 	for (const field of usableFields) {
-		const value = fixtureValueForType(field.type, field.name, model.name);
+		const camelValue = fixtureValueForType(field.type, field.name, model.name, modelMap);
+		const wireValue = fixtureValueForType(field.type, field.name, model.name, modelMap, true);
 		const camelKey = fieldName(field.name);
 		const snakeKey = wireFieldName(field.name);
-		camelEntries.push(`${camelKey}: ${value}`);
-		snakeEntries.push(`${snakeKey}: ${value}`);
+		camelEntries.push(`${camelKey}: ${camelValue}`);
+		snakeEntries.push(`${snakeKey}: ${wireValue}`);
 	}
 	return {
 		camelCaseObj: `{ ${camelEntries.join(", ")} }`,
@@ -3413,7 +3926,7 @@ function generateSerializerTests(spec, ctx) {
 	const modelToService = assignModelsToServices$1(spec.models, spec.services);
 	const serviceNameMap = /* @__PURE__ */ new Map();
 	for (const service of spec.services) serviceNameMap.set(service.name, resolveResourceClassName(service, ctx));
-	const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
+	const resolveDir = (irService) => irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : "common";
 	const eligibleModels = spec.models.filter((m) => modelNeedsRoundTripTest(m) && !isListMetadataModel(m) && !isListWrapperModel(m));
 	if (eligibleModels.length === 0) return files;
 	const modelsByDir = /* @__PURE__ */ new Map();
@@ -3483,37 +3996,72 @@ function generateManifest(spec, ctx) {
 }
 //#endregion
 //#region src/node/index.ts
+/** Ensure every generated file's content ends with a trailing newline. */
+function ensureTrailingNewlines(files) {
+	for (const f of files) if (f.content && !f.content.endsWith("\n")) f.content += "\n";
+	return files;
+}
 const nodeEmitter = {
 	language: "node",
 	generateModels(models, ctx) {
-		return [...generateModels(models, ctx), ...generateSerializers(models, ctx)];
+		return ensureTrailingNewlines([...generateModels(models, ctx), ...generateSerializers(models, ctx)]);
 	},
 	generateEnums(enums, ctx) {
-		return generateEnums(enums, ctx);
+		return ensureTrailingNewlines(generateEnums(enums, ctx));
 	},
 	generateResources(services, ctx) {
-		return generateResources(services, ctx);
+		return ensureTrailingNewlines(generateResources(services, ctx));
 	},
 	generateClient(spec, ctx) {
-		return generateClient(spec, ctx);
+		return ensureTrailingNewlines(generateClient(spec, ctx));
 	},
 	generateErrors(ctx) {
-		return generateErrors(ctx);
+		return ensureTrailingNewlines(generateErrors(ctx));
 	},
 	generateConfig(_ctx) {
-		return [...generateConfig(), ...generateCommon()];
+		return ensureTrailingNewlines([...generateConfig(), ...generateCommon()]);
 	},
 	generateTypeSignatures(_spec, _ctx) {
 		return [];
 	},
 	generateTests(spec, ctx) {
-		return generateTests(spec, ctx);
+		return ensureTrailingNewlines(generateTests(spec, ctx));
 	},
 	generateManifest(spec, ctx) {
-		return generateManifest(spec, ctx);
+		return ensureTrailingNewlines(generateManifest(spec, ctx));
 	},
 	fileHeader() {
 		return "// This file is auto-generated by oagen. Do not edit.";
+	},
+	formatCommand(targetDir) {
+		const hasPrettier = fs.existsSync(path.join(targetDir, ".prettierrc"));
+		const hasEslint = fs.existsSync(path.join(targetDir, "eslint.config.mjs")) || fs.existsSync(path.join(targetDir, "eslint.config.js")) || fs.existsSync(path.join(targetDir, ".eslintrc.json")) || fs.existsSync(path.join(targetDir, ".eslintrc.js"));
+		if (hasPrettier && hasEslint) return {
+			cmd: "bash",
+			args: [
+				"-c",
+				"npx eslint --fix --no-error-on-unmatched-pattern \"$@\" 2>/dev/null; npx prettier --write --log-level silent \"$@\"",
+				"--"
+			]
+		};
+		if (hasPrettier) return {
+			cmd: "npx",
+			args: [
+				"prettier",
+				"--write",
+				"--log-level",
+				"silent"
+			]
+		};
+		if (hasEslint) return {
+			cmd: "npx",
+			args: [
+				"eslint",
+				"--fix",
+				"--no-error-on-unmatched-pattern"
+			]
+		};
+		return null;
 	}
 };
 //#endregion