@workos/oagen-emitters 0.0.1 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,3522 @@
+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). */
+function fileName(name) {
+	return toKebabCase(name);
+}
+/** camelCase field name for domain interfaces. */
+function fieldName(name) {
+	return toCamelCase(name);
+}
+/** snake_case field name for wire/response interfaces. */
+function wireFieldName(name) {
+	return toSnakeCase(name);
+}
+/**
+* Wire/response interface name. Uses "Wire" suffix when the domain name
+* already ends in "Response" to avoid stuttering (e.g., FooResponseResponse).
+*/
+function wireInterfaceName(domainName) {
+	return domainName.endsWith("Response") ? `${domainName}Wire` : `${domainName}Response`;
+}
+/** kebab-case service directory name. */
+function serviceDirName(name) {
+	return toKebabCase(name);
+}
+/** camelCase property name for service accessors on the client. */
+function servicePropertyName(name) {
+	return toCamelCase(name);
+}
+/**
+* Resolve the effective service name, using the overlay-resolved class name
+* when available. This ensures directory names, file names, and property names
+* all derive from the same resolved name (e.g., "Mfa" instead of "MultiFactorAuth").
+*/
+function resolveServiceName(service, ctx) {
+	return resolveClassName(service, ctx);
+}
+/**
+* Build a map from IR service name → resolved service name.
+* Used to translate modelToService/enumToService map values to overlay-resolved
+* directory names when the code only has the IR service name string.
+*/
+function buildServiceNameMap(services, ctx) {
+	const map = /* @__PURE__ */ new Map();
+	for (const service of services) map.set(service.name, resolveServiceName(service, ctx));
+	return map;
+}
+/** Resolve the SDK method name for an operation, checking overlay first. */
+function resolveMethodName(op, _service, ctx) {
+	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+	const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
+	if (existing) {
+		if (/\/\{[^}]+\}$/.test(op.path) && existing.methodName.endsWith("s") && !existing.methodName.endsWith("ss")) {
+			const singular = existing.methodName.slice(0, -1);
+			const specDerived = toCamelCase(op.name);
+			if (specDerived === singular || specDerived.endsWith(singular.slice(singular.length - 4))) return singular;
+		}
+		return existing.methodName;
+	}
+	return toCamelCase(op.name);
+}
+/** Resolve the SDK class name for a service, checking overlay for existing names. */
+function resolveClassName(service, ctx) {
+	if (ctx.overlayLookup?.methodByOperation) for (const op of service.operations) {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const existing = ctx.overlayLookup.methodByOperation.get(httpKey);
+		if (existing) return existing.className;
+	}
+	return toPascalCase(service.name);
+}
+/** Resolve the interface name for a model, checking overlay first. */
+function resolveInterfaceName(name, ctx) {
+	const existing = ctx.overlayLookup?.interfaceByName?.get(name);
+	if (existing) return existing;
+	return toPascalCase(name);
+}
+//#endregion
+//#region src/node/type-map.ts
+/**
+* Map an IR TypeRef to a TypeScript domain type string.
+* Domain types use PascalCase model names (e.g., `Organization`).
+*
+* @param opts.stringDates - When true, map `date-time` to `string` instead of `Date`.
+*   Use this when integrating into an existing SDK that represents timestamps as
+*   ISO 8601 strings rather than Date objects.
+* @param opts.genericDefaults - When present, appends default type args to generic model refs.
+*/
+function mapTypeRef$1(ref, opts) {
+	const primMapper = opts?.stringDates ? mapPrimitiveStringDates : mapPrimitive;
+	const genericDefaults = opts?.genericDefaults;
+	return mapTypeRef(ref, {
+		primitive: primMapper,
+		array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+		model: (r) => r.name + (genericDefaults?.get(r.name) ?? ""),
+		enum: (r) => r.name,
+		union: (r, variants) => joinUnionVariants(r, variants),
+		nullable: (_r, inner) => `${inner} | null`,
+		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
+		map: (_r, value) => `Record<string, ${value}>`
+	});
+}
+/**
+* Map an IR TypeRef to a TypeScript wire/response type string.
+* Model references get the `Response` suffix (e.g., `OrganizationResponse`).
+* Wire types use JSON-native types (string for date-time, number/string for int64).
+*/
+function mapWireTypeRef(ref, opts) {
+	const genericDefaults = opts?.genericDefaults;
+	return mapTypeRef(ref, {
+		primitive: mapWirePrimitive,
+		array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+		model: (r) => wireInterfaceName(r.name) + (genericDefaults?.get(r.name) ?? ""),
+		enum: (r) => r.name,
+		union: (r, variants) => joinUnionVariants(r, variants),
+		nullable: (_r, inner) => `${inner} | null`,
+		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
+		map: (_r, value) => `Record<string, ${value}>`
+	});
+}
+function mapPrimitive(ref) {
+	if (ref.format) switch (ref.format) {
+		case "date-time": return "Date";
+		case "int64": return "bigint";
+	}
+	switch (ref.type) {
+		case "string": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "unknown": return "any";
+	}
+}
+/**
+* Map a primitive type using string representation for dates.
+* Used when the existing SDK represents timestamps as ISO 8601 strings.
+*/
+function mapPrimitiveStringDates(ref) {
+	if (ref.format) switch (ref.format) {
+		case "int64": return "bigint";
+	}
+	switch (ref.type) {
+		case "string": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "unknown": return "any";
+	}
+}
+/**
+* Map an IR PrimitiveType to a TypeScript wire/JSON type string.
+* Wire types match JSON encoding: date-time stays string, int64 stays string/number.
+*/
+function mapWirePrimitive(ref) {
+	switch (ref.type) {
+		case "string": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "unknown": return "any";
+	}
+}
+/**
+* Join union variant type strings using the appropriate operator.
+* allOf unions use `&` (intersection), oneOf/anyOf/unspecified use `|` (union).
+*/
+function joinUnionVariants(ref, variants) {
+	if (ref.compositionKind === "allOf") return variants.join(" & ");
+	return variants.join(" | ");
+}
+/** Wrap union/intersection types in parentheses when used as array item type. */
+function parenthesizeUnion(type) {
+	return type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
+}
+//#endregion
+//#region src/node/utils.ts
+/**
+* Compute a relative import path between two files within the generated SDK.
+* Strips .ts extension from the result.
+*/
+function relativeImport(fromFile, toFile) {
+	const fromDir = fromFile.split("/").slice(0, -1);
+	const toFileParts = toFile.split("/");
+	const toDir = toFileParts.slice(0, -1);
+	const toFileName = toFileParts[toFileParts.length - 1];
+	let common = 0;
+	while (common < fromDir.length && common < toDir.length && fromDir[common] === toDir[common]) common++;
+	const ups = fromDir.length - common;
+	const downs = toDir.slice(common);
+	let result = [
+		...Array(ups).fill(".."),
+		...downs,
+		toFileName
+	].join("/");
+	result = result.replace(/\.ts$/, "");
+	if (!result.startsWith(".")) result = "./" + result;
+	return result;
+}
+/**
+* Render a JSDoc comment block from a description string.
+* Handles multiline descriptions by prefixing each line with ` * `.
+* Returns the lines with the given indent (default 0 spaces).
+*/
+function docComment(description, indent = 0) {
+	const pad = " ".repeat(indent);
+	const descLines = description.split("\n");
+	if (descLines.length === 1) return [`${pad}/** ${descLines[0]} */`];
+	const lines = [`${pad}/**`];
+	for (const line of descLines) lines.push(line === "" ? `${pad} *` : `${pad} * ${line}`);
+	lines.push(`${pad} */`);
+	return lines;
+}
+/**
+* Build a map from model name → default type args string for generic models.
+* E.g., Profile<CustomAttributesType = Record<string, unknown>>
+*   → Map { 'Profile' → '<Record<string, unknown>>' }
+*
+* Non-generic models are not included in the map.
+*/
+function buildGenericModelDefaults(models) {
+	const result = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		if (!model.typeParams?.length) continue;
+		const defaults = model.typeParams.map((tp) => tp.default ? mapTypeRef$1(tp.default) : "unknown");
+		result.set(model.name, `<${defaults.join(", ")}>`);
+	}
+	return result;
+}
+/**
+* Remove unused imports from generated source code.
+* Scans the non-import body for each imported identifier and drops
+* individual names that are never referenced.  Removes entire import
+* statements when no names are used.
+*/
+function pruneUnusedImports(lines) {
+	const importLines = [];
+	const bodyLines = [];
+	let inBody = false;
+	for (const line of lines) if (!inBody && (line.startsWith("import ") || line === "")) importLines.push(line);
+	else {
+		inBody = true;
+		bodyLines.push(line);
+	}
+	const body = bodyLines.join("\n");
+	const kept = [];
+	for (const line of importLines) {
+		if (line === "") {
+			kept.push(line);
+			continue;
+		}
+		const match = line.match(/\{([^}]+)\}/);
+		if (!match) {
+			kept.push(line);
+			continue;
+		}
+		const names = match[1].split(",").map((n) => n.trim()).filter(Boolean);
+		const usedNames = names.filter((name) => {
+			return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(body);
+		});
+		if (usedNames.length === 0) continue;
+		if (usedNames.length === names.length) kept.push(line);
+		else {
+			const isTypeImport = line.startsWith("import type");
+			const fromMatch = line.match(/from\s+['"]([^'"]+)['"]/);
+			if (fromMatch) {
+				const prefix = isTypeImport ? "import type" : "import";
+				kept.push(`${prefix} { ${usedNames.join(", ")} } from '${fromMatch[1]}';`);
+			} else kept.push(line);
+		}
+	}
+	return [...kept, ...bodyLines];
+}
+/** Built-in TypeScript types that are always available (no import needed). */
+const TS_BUILTINS = new Set([
+	"Record",
+	"Promise",
+	"Array",
+	"Map",
+	"Set",
+	"Date",
+	"string",
+	"number",
+	"boolean",
+	"void",
+	"null",
+	"undefined",
+	"any",
+	"never",
+	"unknown",
+	"true",
+	"false"
+]);
+/**
+* Detect whether the existing SDK uses string (ISO 8601) representation for
+* date-time fields.  Checks if any baseline interface has a date-time IR field
+* typed as plain `string` (not `Date`).
+*/
+function detectStringDateConvention(models, ctx) {
+	if (!ctx.apiSurface?.interfaces) return false;
+	for (const model of models) {
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const baseline = ctx.apiSurface.interfaces[domainName];
+		if (!baseline?.fields) continue;
+		for (const field of model.fields) {
+			if (field.type.kind !== "primitive" || field.type.format !== "date-time") continue;
+			const baselineField = baseline.fields[fieldName(field.name)];
+			if (baselineField && !baselineField.type.includes("Date")) return true;
+		}
+	}
+	return false;
+}
+/**
+* Build a comprehensive set of all known type names from the IR and baseline.
+* Used to identify type parameters by elimination — any PascalCase name not in
+* this set is likely a generic type parameter.
+*/
+function buildKnownTypeNames(models, ctx) {
+	const knownNames = /* @__PURE__ */ new Set();
+	for (const m of models) knownNames.add(resolveInterfaceName(m.name, ctx));
+	for (const e of ctx.spec.enums) knownNames.add(e.name);
+	if (ctx.apiSurface?.interfaces) for (const name of Object.keys(ctx.apiSurface.interfaces)) knownNames.add(name);
+	if (ctx.apiSurface?.typeAliases) for (const name of Object.keys(ctx.apiSurface.typeAliases)) knownNames.add(name);
+	if (ctx.apiSurface?.enums) for (const name of Object.keys(ctx.apiSurface.enums)) knownNames.add(name);
+	return knownNames;
+}
+/**
+* Create a service directory resolver bundle.
+* Encapsulates the common pattern of mapping models to services and resolving
+* the output directory for a given IR service name.
+*/
+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";
+	return {
+		modelToService,
+		serviceNameMap,
+		resolveDir
+	};
+}
+/**
+* Check if a set of baseline interface fields appears to contain generic type
+* parameters — PascalCase names that aren't known models, enums, or builtins.
+*/
+function isBaselineGeneric(fields, knownNames) {
+	for (const [, bf] of Object.entries(fields)) {
+		const typeNames = bf.type.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+		if (!typeNames) continue;
+		for (const tn of typeNames) {
+			if (TS_BUILTINS.has(tn)) continue;
+			if (knownNames.has(tn)) continue;
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Detect whether a model matches the standard list-metadata shape:
+* exactly 2 fields named `before` and `after`, both nullable string.
+*
+* These models are redundant because the SDK already has a shared
+* `ListMetadata` type in `src/common/utils/pagination.ts`.
+*/
+function isListMetadataModel(model) {
+	if (model.fields.length !== 2) return false;
+	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+	const before = fieldsByName.get("before");
+	const after = fieldsByName.get("after");
+	if (!before || !after) return false;
+	return isNullableString(before) && isNullableString(after);
+}
+/**
+* Detect whether a model is a list wrapper — the standard paginated
+* list envelope with `data` (array), `list_metadata`, and `object: 'list'`.
+*
+* These models are redundant because the SDK already has `List<T>` and
+* `ListResponse<T>` in `src/common/utils/pagination.ts`, and the shared
+* `deserializeList` handles deserialization.
+*/
+function isListWrapperModel(model) {
+	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+	const dataField = fieldsByName.get("data");
+	if (!dataField) return false;
+	if (dataField.type.kind !== "array") return false;
+	if (!fieldsByName.get("list_metadata")) return false;
+	const objectField = fieldsByName.get("object");
+	if (objectField) {
+		if (objectField.type.kind !== "literal" || objectField.type.value !== "list") return false;
+	}
+	return true;
+}
+/** Check if a field type is nullable string (nullable<string> or just string). */
+function isNullableString(field) {
+	const { type } = field;
+	if (type.kind === "nullable") return type.inner.kind === "primitive" && type.inner.type === "string";
+	if (type.kind === "primitive") return type.type === "string";
+	return false;
+}
+/**
+* Compute a structural fingerprint for a model based on its fields.
+* Two models with identical fingerprints are structurally equivalent.
+*/
+function modelFingerprint(model) {
+	return model.fields.map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`).sort().join("|");
+}
+/**
+* Find structurally identical models and build a deduplication map.
+* Also deduplicates models that resolve to the same interface name across
+* services — when a `$ref` schema is used by multiple tags, the IR may
+* produce per-tag copies that diverge slightly.  The version with the most
+* fields is chosen as canonical.
+*
+* Returns a Map from duplicate model name → canonical model name.
+*/
+function buildDeduplicationMap(models, ctx) {
+	const dedup = /* @__PURE__ */ new Map();
+	const fingerprints = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		if (model.fields.length === 0) continue;
+		const fp = modelFingerprint(model);
+		const existing = fingerprints.get(fp);
+		if (existing) dedup.set(model.name, existing);
+		else fingerprints.set(fp, model.name);
+	}
+	if (ctx) {
+		const byDomainName = /* @__PURE__ */ new Map();
+		for (const model of models) {
+			if (model.fields.length === 0) continue;
+			if (dedup.has(model.name)) continue;
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const group = byDomainName.get(domainName);
+			if (group) group.push(model);
+			else byDomainName.set(domainName, [model]);
+		}
+		for (const [, group] of byDomainName) {
+			if (group.length < 2) continue;
+			group.sort((a, b) => b.fields.length - a.fields.length || a.name.localeCompare(b.name));
+			const canonical = group[0];
+			for (let i = 1; i < group.length; i++) dedup.set(group[i].name, canonical.name);
+		}
+	}
+	return dedup;
+}
+/**
+* Check whether a service's endpoints are already fully covered by existing
+* hand-written service classes.
+*
+* A service is considered "covered" when:
+* 1. **Every** operation in it appears in `overlayLookup.methodByOperation`
+* 2. The overlay maps those operations to a class that exists in the baseline
+*    `apiSurface` (confirming the hand-written class is actually present)
+*
+* Services with zero operations are never considered covered (nothing to
+* deduplicate).  When no `apiSurface` is available, the overlay alone is
+* used as the coverage signal (the overlay is only built from existing code).
+*
+* This prevents the emitter from generating resource classes like `Connections`
+* that would duplicate hand-written modules like `SSO` for the same API
+* endpoints (e.g., `GET /connections`).
+*/
+function isServiceCoveredByExisting(service, ctx) {
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay || overlay.size === 0) return false;
+	if (service.operations.length === 0) return false;
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return false;
+	const existingClassNames = new Set(Object.keys(baselineClasses));
+	return service.operations.every((op) => {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) return false;
+		return existingClassNames.has(match.className);
+	});
+}
+/**
+* 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.
+*/
+function uncoveredOperations(service, ctx) {
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay || overlay.size === 0) return service.operations;
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return service.operations;
+	const existingClassNames = new Set(Object.keys(baselineClasses));
+	return service.operations.filter((op) => {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) return true;
+		return !existingClassNames.has(match.className);
+	});
+}
+//#endregion
+//#region src/node/enums.ts
+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 files = [];
+	for (const enumDef of enums) {
+		const dirName = resolveDir(enumToService.get(enumDef.name));
+		const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
+		const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
+		const lines = [];
+		let hasNewValues = false;
+		if (baselineEnum?.members) {
+			const existingValues = new Set(Object.values(baselineEnum.members).map(String));
+			const missingValues = enumDef.values.map((v) => String(v.value)).filter((v) => !existingValues.has(v));
+			hasNewValues = missingValues.length > 0;
+			lines.push(`export enum ${enumDef.name} {`);
+			for (const [memberName, memberValue] of Object.entries(baselineEnum.members)) {
+				const valueStr = typeof memberValue === "string" ? `'${memberValue}'` : String(memberValue);
+				lines.push(`  ${memberName} = ${valueStr},`);
+			}
+			for (const val of missingValues) {
+				const memberName = val.replace(/[^a-zA-Z0-9]+/g, "");
+				lines.push(`  ${memberName} = '${val}',`);
+			}
+			lines.push("}");
+		} else if (baselineAlias?.value) {
+			const baselineValues = extractLiteralUnionValues(baselineAlias.value);
+			const missing = enumDef.values.map((v) => String(v.value)).filter((v) => !baselineValues.has(v));
+			hasNewValues = missing.length > 0;
+			if (missing.length > 0) {
+				const parts = [...baselineValues, ...missing].map((v) => `'${v}'`);
+				lines.push(`export type ${enumDef.name} = ${parts.join(" | ")};`);
+			} else lines.push(`export type ${enumDef.name} = ${baselineAlias.value};`);
+		} else {
+			const values = enumDef.values;
+			lines.push(`export type ${enumDef.name} =`);
+			for (let i = 0; i < values.length; i++) {
+				const v = values[i];
+				const valueStr = typeof v.value === "string" ? `'${v.value}'` : String(v.value);
+				if (v.description || v.deprecated) {
+					const parts = [];
+					if (v.description) parts.push(v.description);
+					if (v.deprecated) parts.push("@deprecated");
+					lines.push(...docComment(parts.join("\n"), 2));
+				}
+				const suffix = i === values.length - 1 ? ";" : "";
+				lines.push(`  | ${valueStr}${suffix}`);
+			}
+		}
+		files.push({
+			path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
+			content: lines.join("\n"),
+			skipIfExists: !hasNewValues
+		});
+	}
+	return files;
+}
+/**
+* Parse a TypeScript string literal union type alias value (e.g., "'a' | 'b' | 'c'")
+* into a set of its string values.
+*/
+function extractLiteralUnionValues(aliasValue) {
+	const values = /* @__PURE__ */ new Set();
+	const regex = /'([^']+)'/g;
+	let match;
+	while ((match = regex.exec(aliasValue)) !== null) values.add(match[1]);
+	return values;
+}
+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/node/models.ts
+/**
+* Detect baseline interfaces that are generic (have type parameters) even though
+* the IR model has no typeParams (OpenAPI doesn't support generics).
+*
+* Heuristic: if any field type in the baseline interface contains a PascalCase
+* name that isn't a known model, enum, or builtin, it's likely a type parameter
+* (e.g., `CustomAttributesType`), indicating the interface is generic.
+*
+* When detected, adds a default generic type arg so references like `Profile`
+* become `Profile<Record<string, unknown>>`.
+*/
+function enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService) {
+	if (!ctx.apiSurface?.interfaces) return;
+	const knownNames = buildKnownTypeNames(models, ctx);
+	for (const model of models) {
+		if (genericDefaults.has(model.name)) continue;
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const baseline = ctx.apiSurface.interfaces[domainName];
+		if (!baseline?.fields) continue;
+		const generatedPath = `src/${resolveDir(modelToService.get(model.name))}/interfaces/${fileName(model.name)}.interface.ts`;
+		const baselineSourceFile = baseline.sourceFile;
+		if (baselineSourceFile && baselineSourceFile !== generatedPath) continue;
+		if (isBaselineGeneric(baseline.fields, knownNames)) genericDefaults.set(model.name, "<Record<string, unknown>>");
+	}
+}
+function generateModels(models, ctx) {
+	if (models.length === 0) return [];
+	const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
+	const useStringDates = detectStringDateConvention(models, ctx);
+	const genericDefaults = buildGenericModelDefaults(ctx.spec.models);
+	enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService);
+	const typeRefOpts = useStringDates ? {
+		stringDates: true,
+		genericDefaults
+	} : { genericDefaults };
+	const wireTypeRefOpts = { genericDefaults };
+	const files = [];
+	const dedup = buildDeduplicationMap(models, ctx);
+	for (const model of models) {
+		if (isListMetadataModel(model)) continue;
+		if (isListWrapperModel(model)) continue;
+		const canonicalName = dedup.get(model.name);
+		if (canonicalName) {
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const responseName = wireInterfaceName(domainName);
+			const canonDomainName = resolveInterfaceName(canonicalName, ctx);
+			const canonResponseName = wireInterfaceName(canonDomainName);
+			const dirName = resolveDir(modelToService.get(model.name));
+			const canonDir = resolveDir(modelToService.get(canonicalName));
+			const aliasLines = [
+				`import type { ${canonDomainName}, ${canonResponseName} } from '${canonDir === dirName ? `./${fileName(canonicalName)}.interface` : `../../${canonDir}/interfaces/${fileName(canonicalName)}.interface`}';`,
+				"",
+				`export type ${domainName} = ${canonDomainName};`,
+				`export type ${responseName} = ${canonResponseName};`
+			];
+			files.push({
+				path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
+				content: aliasLines.join("\n"),
+				skipIfExists: true
+			});
+			continue;
+		}
+		const dirName = resolveDir(modelToService.get(model.name));
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const responseName = wireInterfaceName(domainName);
+		const deps = collectFieldDependencies(model);
+		const lines = [];
+		let modelTypeRefOpts = typeRefOpts;
+		let modelWireTypeRefOpts = wireTypeRefOpts;
+		if (genericDefaults.has(model.name)) {
+			const filteredDefaults = new Map(genericDefaults);
+			filteredDefaults.delete(model.name);
+			modelTypeRefOpts = {
+				...typeRefOpts,
+				genericDefaults: filteredDefaults
+			};
+			modelWireTypeRefOpts = { genericDefaults: filteredDefaults };
+		}
+		const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
+		const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
+		const importableNames = /* @__PURE__ */ new Set();
+		importableNames.add(domainName);
+		importableNames.add(responseName);
+		for (const dep of deps.models) {
+			const depName = resolveInterfaceName(dep, ctx);
+			importableNames.add(depName);
+			importableNames.add(wireInterfaceName(depName));
+		}
+		for (const dep of deps.enums) importableNames.add(dep);
+		const typeDecls = /* @__PURE__ */ new Map();
+		const crossServiceImports = /* @__PURE__ */ new Map();
+		const unresolvableNames = /* @__PURE__ */ new Set();
+		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) {
+			const baselineFields = [baselineDomain?.fields?.[fieldName(field.name)], baselineResponse?.fields?.[wireFieldName(field.name)]].filter(Boolean);
+			for (const bf of baselineFields) {
+				const names = bf.type.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+				if (!names) continue;
+				for (const name of names) {
+					if (TS_BUILTINS.has(name)) continue;
+					if (importableNames.has(name)) continue;
+					if (typeDecls.has(name)) continue;
+					if (crossServiceImports.has(name)) continue;
+					if (unresolvableNames.has(name)) continue;
+					const irEnumName = resolvedEnumNames.get(name);
+					if (irEnumName && !deps.enums.has(irEnumName)) {
+						const eDir = resolveDir(enumToService.get(irEnumName));
+						const relPath = eDir === dirName ? `./${fileName(irEnumName)}.interface` : `../../${eDir}/interfaces/${fileName(irEnumName)}.interface`;
+						crossServiceImports.set(name, {
+							name,
+							relPath
+						});
+						importableNames.add(name);
+						continue;
+					}
+					const candidates = [...importableNames].filter((n) => n.endsWith(name) && n !== name);
+					if (candidates.length === 1) {
+						typeDecls.set(name, candidates[0]);
+						importableNames.add(name);
+					} else unresolvableNames.add(name);
+				}
+			}
+		}
+		for (const dep of deps.models) {
+			const depName = resolveInterfaceName(dep, ctx);
+			const depDir = resolveDir(modelToService.get(dep));
+			const relPath = depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
+			lines.push(`import type { ${depName}, ${wireInterfaceName(depName)} } from '${relPath}';`);
+		}
+		for (const dep of deps.enums) {
+			const depDir = resolveDir(enumToService.get(dep));
+			const relPath = depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
+			lines.push(`import type { ${dep} } from '${relPath}';`);
+		}
+		for (const [, imp] of crossServiceImports) lines.push(`import type { ${imp.name} } from '${imp.relPath}';`);
+		if (lines.length > 0) lines.push("");
+		for (const [alias, typeExpr] of typeDecls) lines.push(`type ${alias} = ${typeExpr};`);
+		if (typeDecls.size > 0) lines.push("");
+		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)};`);
+			}
+		}
+		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)};`);
+			}
+		}
+		lines.push("}");
+		files.push({
+			path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
+			content: pruneUnusedImports(lines).join("\n"),
+			skipIfExists: true
+		});
+	}
+	return files;
+}
+/**
+* Check if all PascalCase type references in a baseline type string
+* can be resolved to types that are actually importable in the generated file.
+* A type is importable if it's a builtin, or if it's among the set of names
+* that will be imported (the model's own name/response, or its IR deps).
+* Returns false if any reference is unresolvable (e.g., hand-written types
+* from the live SDK, or spec types from other services not in IR deps).
+*/
+function baselineTypeResolvable(typeStr, importableNames) {
+	const matches = typeStr.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+	if (!matches) return true;
+	for (const name of matches) {
+		if (TS_BUILTINS.has(name)) continue;
+		if (importableNames.has(name)) continue;
+		return false;
+	}
+	return true;
+}
+/**
+* Check if a baseline field type is compatible with the IR field for use
+* in the generated interface. The serializer generates expressions based on
+* the IR type, so the interface type must be assignable from the serializer output.
+*
+* Rejects baseline types when:
+* - IR field is nullable but baseline type doesn't include `null`
+* - IR field is optional but baseline says required (and vice versa)
+* - IR field is required but baseline says optional
+*/
+function baselineFieldCompatible(baselineField, irField) {
+	const irNullable = irField.type.kind === "nullable";
+	const baselineHasNull = baselineField.type.includes("null");
+	if (irNullable && !baselineHasNull && irField.required) return false;
+	if (!irField.required && !baselineField.optional && !baselineField.type.includes("undefined")) return false;
+	if (baselineField.type === "Record<string, unknown>" && hasSpecificIRType(irField.type)) return false;
+	return true;
+}
+/** Check if an IR type is more specific than Record<string, unknown>. */
+function hasSpecificIRType(ref) {
+	switch (ref.kind) {
+		case "model":
+		case "enum": return true;
+		case "union": return ref.variants.some((v) => v.kind === "model" || v.kind === "enum");
+		case "nullable": return hasSpecificIRType(ref.inner);
+		default: return false;
+	}
+}
+function renderTypeParams(model, genericDefaults) {
+	if (!model.typeParams?.length) {
+		if (genericDefaults?.has(model.name)) return "<GenericType extends Record<string, unknown> = Record<string, unknown>>";
+		return "";
+	}
+	return `<${model.typeParams.map((tp) => {
+		const def = tp.default ? ` = ${mapTypeRef$1(tp.default)}` : "";
+		return `${tp.name}${def}`;
+	}).join(", ")}>`;
+}
+//#endregion
+//#region src/node/serializers.ts
+/**
+* Render generic type parameter declarations for a model.
+* E.g., `<CustomAttributesType = Record<string, unknown>>`.
+* Returns empty string for non-generic models.
+*/
+function renderSerializerTypeParams(model, ctx) {
+	if (model.typeParams?.length) {
+		const params = model.typeParams.map((tp) => {
+			const def = tp.default ? ` = ${mapTypeRef$1(tp.default)}` : "";
+			return `${tp.name}${def}`;
+		});
+		const names = model.typeParams.map((tp) => tp.name);
+		return {
+			decl: `<${params.join(", ")}>`,
+			usage: `<${names.join(", ")}>`
+		};
+	}
+	if (ctx?.apiSurface?.interfaces) {
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const baseline = ctx.apiSurface.interfaces[domainName];
+		if (baseline?.fields) {
+			const baselineSourceFile = baseline.sourceFile;
+			const { modelToService, resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
+			const generatedPath = `src/${resolveDir(modelToService.get(model.name))}/interfaces/${fileName(model.name)}.interface.ts`;
+			const pathMatches = !baselineSourceFile || baselineSourceFile === generatedPath;
+			const knownNames = buildKnownTypeNames(ctx.spec.models, ctx);
+			if (pathMatches && isBaselineGeneric(baseline.fields, knownNames)) return {
+				decl: "<GenericType extends Record<string, unknown> = Record<string, unknown>>",
+				usage: "<GenericType>"
+			};
+		}
+	}
+	return {
+		decl: "",
+		usage: ""
+	};
+}
+function generateSerializers(models, ctx) {
+	if (models.length === 0) return [];
+	const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
+	const useStringDates = detectStringDateConvention(models, ctx);
+	const files = [];
+	const dedup = buildDeduplicationMap(models, ctx);
+	const skippedSerializeModels = /* @__PURE__ */ new Set();
+	for (const model of models) {
+		if (isListMetadataModel(model)) continue;
+		if (isListWrapperModel(model)) continue;
+		const canonicalName = dedup.get(model.name);
+		if (canonicalName) {
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const canonDomainName = resolveInterfaceName(canonicalName, ctx);
+			const dirName = resolveDir(modelToService.get(model.name));
+			const canonDir = resolveDir(modelToService.get(canonicalName));
+			const serializerPath = `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
+			const aliasLines = [`export { deserialize${canonDomainName} as deserialize${domainName}, serialize${canonDomainName} as serialize${domainName} } from '${relativeImport(serializerPath, `src/${canonDir}/serializers/${fileName(canonicalName)}.serializer.ts`)}';`];
+			files.push({
+				path: serializerPath,
+				content: aliasLines.join("\n")
+			});
+			continue;
+		}
+		const dirName = resolveDir(modelToService.get(model.name));
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const responseName = wireInterfaceName(domainName);
+		const serializerPath = `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
+		const typeParams = renderSerializerTypeParams(model, ctx);
+		const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
+		const skipFormatFields = /* @__PURE__ */ new Set();
+		const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
+		let shouldSkipSerialize = serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx);
+		if (!shouldSkipSerialize) for (const field of model.fields) {
+			for (const ref of collectSerializedModelRefs(field.type)) {
+				if (skippedSerializeModels.has(ref)) {
+					shouldSkipSerialize = true;
+					break;
+				}
+				const canon = dedup.get(ref);
+				if (canon && skippedSerializeModels.has(canon)) {
+					shouldSkipSerialize = true;
+					break;
+				}
+			}
+			if (shouldSkipSerialize) break;
+		}
+		if (shouldSkipSerialize) skippedSerializeModels.add(model.name);
+		if (useStringDates) {
+			for (const field of model.fields) if (hasDateTimeConversion(field.type)) skipFormatFields.add(field.name);
+		}
+		if (baselineDomain) for (const field of model.fields) {
+			if (skipFormatFields.has(field.name)) continue;
+			const baselineField = baselineDomain.fields?.[fieldName(field.name)];
+			if (baselineField && !baselineField.type.includes("Date") && hasFormatConversion(field.type)) skipFormatFields.add(field.name);
+		}
+		const nestedModelRefs = /* @__PURE__ */ new Set();
+		for (const field of model.fields) for (const ref of collectSerializedModelRefs(field.type)) if (ref !== model.name) nestedModelRefs.add(ref);
+		const lines = [];
+		const interfacePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
+		lines.push(`import type { ${domainName}, ${responseName} } from '${relativeImport(serializerPath, interfacePath)}';`);
+		for (const dep of nestedModelRefs) {
+			const depSerializerPath = `src/${resolveDir(modelToService.get(dep))}/serializers/${fileName(dep)}.serializer.ts`;
+			const depName = resolveInterfaceName(dep, ctx);
+			const rel = relativeImport(serializerPath, depSerializerPath);
+			lines.push(`import { deserialize${depName}, serialize${depName} } from '${rel}';`);
+		}
+		lines.push("");
+		const seenDeserFields = /* @__PURE__ */ new Set();
+		const deserParamPrefix = model.fields.length === 0 ? "_" : "";
+		lines.push(`export const deserialize${domainName} = ${typeParams.decl}(`);
+		lines.push(`  ${deserParamPrefix}response: ${responseName}${typeParams.usage},`);
+		lines.push(`): ${domainName}${typeParams.usage} => ({`);
+		for (const field of model.fields) {
+			const domain = fieldName(field.name);
+			if (seenDeserFields.has(domain)) continue;
+			seenDeserFields.add(domain);
+			const wire = wireFieldName(field.name);
+			const wireAccess = `response.${wire}`;
+			const expr = skipFormatFields.has(field.name) ? wireAccess : deserializeExpression(field.type, wireAccess, ctx);
+			const isNewField = baselineDomain && !baselineDomain.fields?.[domain];
+			if ((!field.required || isNewField) && expr !== wireAccess && needsNullGuard(field.type)) {
+				const fallback = field.type.kind === "nullable" ? "null" : "undefined";
+				if (expr.startsWith(`${wireAccess} != null ?`)) lines.push(`  ${domain}: ${expr.replace(/: null$/, `: ${fallback}`)},`);
+				else lines.push(`  ${domain}: ${wireAccess} != null ? ${expr} : ${fallback},`);
+			} else if (field.required && expr === wireAccess) {
+				const fallback = ((baselineResponse?.fields?.[wire])?.optional ?? false) || isNewField ? defaultForType(field.type) : null;
+				if (fallback) lines.push(`  ${domain}: ${expr} ?? ${fallback},`);
+				else lines.push(`  ${domain}: ${expr},`);
+			} else lines.push(`  ${domain}: ${expr},`);
+		}
+		lines.push("});");
+		if (!shouldSkipSerialize) {
+			const serParamPrefix = model.fields.length === 0 ? "_" : "";
+			lines.push("");
+			lines.push(`export const serialize${domainName} = ${typeParams.decl}(`);
+			lines.push(`  ${serParamPrefix}model: ${domainName}${typeParams.usage},`);
+			lines.push(`): ${responseName}${typeParams.usage} => ({`);
+			const seenSerFields = /* @__PURE__ */ new Set();
+			for (const field of model.fields) {
+				const wire = wireFieldName(field.name);
+				if (seenSerFields.has(wire)) continue;
+				seenSerFields.add(wire);
+				const domain = fieldName(field.name);
+				const domainAccess = `model.${domain}`;
+				const expr = skipFormatFields.has(field.name) ? domainAccess : serializeExpression(field.type, domainAccess, ctx);
+				const isNewSerField = baselineDomain && !baselineDomain.fields?.[domain];
+				const effectivelyOptionalSer = !field.required || isNewSerField;
+				const baselineWireField = baselineResponse?.fields?.[wire];
+				const baselineDomainField = baselineDomain?.fields?.[domain];
+				const isNewFieldOnExistingDomain = baselineDomain && !baselineDomainField;
+				const domainFieldIsOptional = !field.required || (baselineDomainField?.optional ?? false) || !!isNewFieldOnExistingDomain;
+				const wireFieldIsRequired = baselineWireField ? !baselineWireField.optional : field.required;
+				const needsUndefinedCoalesce = domainFieldIsOptional && wireFieldIsRequired && expr === domainAccess;
+				const shouldGuardSer = effectivelyOptionalSer || field.type.kind === "nullable";
+				if (expr !== domainAccess && needsNullGuard(field.type) && shouldGuardSer) {
+					const fallback = field.type.kind === "nullable" ? "null" : "undefined";
+					if (expr.startsWith(`${domainAccess} != null ?`)) lines.push(`  ${wire}: ${expr.replace(/: null$/, `: ${fallback}`)},`);
+					else lines.push(`  ${wire}: ${domainAccess} != null ? ${expr} : ${fallback},`);
+				} else if (needsUndefinedCoalesce) if (baselineWireField?.type?.includes("null") || field.type.kind === "nullable") lines.push(`  ${wire}: ${expr} ?? null,`);
+				else lines.push(`  ${wire}: ${expr}!,`);
+				else if (field.type.kind === "nullable" && expr === domainAccess) {
+					const domainWireField2 = wireFieldName(field.name);
+					const responseBaselineField2 = baselineResponse?.fields?.[domainWireField2];
+					const baselineDomainField2 = baselineDomain?.fields?.[domain];
+					const domainResponseMismatch = baselineDomainField2 && !baselineDomainField2.optional && responseBaselineField2 && responseBaselineField2.optional;
+					if (!field.required || isNewSerField || !!domainResponseMismatch) lines.push(`  ${wire}: ${expr} ?? null,`);
+					else lines.push(`  ${wire}: ${expr},`);
+				} else lines.push(`  ${wire}: ${expr},`);
+			}
+			lines.push("});");
+		}
+		files.push({
+			path: serializerPath,
+			content: pruneUnusedImports(lines).join("\n")
+		});
+	}
+	return files;
+}
+/**
+* Collect model names that will actually be called in serialize/deserialize expressions.
+* Unlike collectModelRefs (which walks all union variants), this only includes models
+* that the expression functions will actually invoke a serializer/deserializer for.
+*/
+function collectSerializedModelRefs(ref) {
+	switch (ref.kind) {
+		case "model": return [ref.name];
+		case "array":
+			if (ref.items.kind === "model") return [ref.items.name];
+			return collectSerializedModelRefs(ref.items);
+		case "nullable": return collectSerializedModelRefs(ref.inner);
+		case "union": {
+			const models = uniqueModelVariants(ref);
+			if (ref.discriminator && models.length > 0) return models;
+			if (ref.compositionKind === "allOf" && models.length > 0) return models;
+			if (models.length === 1) return models;
+			return [];
+		}
+		case "map":
+		case "primitive":
+		case "literal":
+		case "enum": return [];
+	}
+}
+function deserializeExpression(ref, wireExpr, ctx) {
+	switch (ref.kind) {
+		case "primitive": return deserializePrimitive(ref, wireExpr);
+		case "literal":
+		case "enum": return wireExpr;
+		case "model": return `deserialize${resolveInterfaceName(ref.name, ctx)}(${wireExpr})`;
+		case "array":
+			if (ref.items.kind === "model") return `${wireExpr}.map(deserialize${resolveInterfaceName(ref.items.name, ctx)})`;
+			return wireExpr;
+		case "nullable": {
+			const innerExpr = deserializeExpression(ref.inner, wireExpr, ctx);
+			if (innerExpr !== wireExpr) return `${wireExpr} != null ? ${innerExpr} : null`;
+			return `${wireExpr} ?? null`;
+		}
+		case "union": {
+			if (ref.discriminator) return renderDiscriminatorSwitch(ref, wireExpr, "deserialize", ctx);
+			if (ref.compositionKind === "allOf") return renderAllOfMerge(ref, wireExpr, "deserialize", ctx);
+			const deserModelVariants = uniqueModelVariants(ref);
+			if (deserModelVariants.length === 1) return `deserialize${resolveInterfaceName(deserModelVariants[0], ctx)}(${wireExpr})`;
+			return wireExpr;
+		}
+		case "map": return wireExpr;
+	}
+}
+function serializeExpression(ref, domainExpr, ctx) {
+	switch (ref.kind) {
+		case "primitive": return serializePrimitive(ref, domainExpr);
+		case "literal":
+		case "enum": return domainExpr;
+		case "model": return `serialize${resolveInterfaceName(ref.name, ctx)}(${domainExpr})`;
+		case "array":
+			if (ref.items.kind === "model") return `${domainExpr}.map(serialize${resolveInterfaceName(ref.items.name, ctx)})`;
+			return domainExpr;
+		case "nullable": {
+			const innerExpr = serializeExpression(ref.inner, domainExpr, ctx);
+			if (innerExpr !== domainExpr) return `${domainExpr} != null ? ${innerExpr} : null`;
+			return domainExpr;
+		}
+		case "union": {
+			if (ref.discriminator) return renderDiscriminatorSwitch(ref, domainExpr, "serialize", ctx);
+			if (ref.compositionKind === "allOf") return renderAllOfMerge(ref, domainExpr, "serialize", ctx);
+			const serModelVariants = uniqueModelVariants(ref);
+			if (serModelVariants.length === 1) return `serialize${resolveInterfaceName(serModelVariants[0], ctx)}(${domainExpr})`;
+			return domainExpr;
+		}
+		case "map": return domainExpr;
+	}
+}
+/**
+* Extract unique model names from a union's variants.
+* Used to determine if a union can be deserialized/serialized as a single model.
+*/
+function uniqueModelVariants(ref) {
+	const modelNames = /* @__PURE__ */ new Set();
+	for (const v of ref.variants) if (v.kind === "model") modelNames.add(v.name);
+	return [...modelNames];
+}
+/**
+* Check whether a TypeRef involves a model reference or format conversion
+* that would produce a function call in serialization/deserialization.
+* Used to determine whether optional fields need a null guard wrapper.
+*/
+function needsNullGuard(ref) {
+	switch (ref.kind) {
+		case "model": return true;
+		case "primitive": return hasFormatConversion(ref);
+		case "array": return ref.items.kind === "model";
+		case "nullable": return needsNullGuard(ref.inner);
+		case "union":
+			if (ref.discriminator) return true;
+			if (ref.compositionKind === "allOf" && uniqueModelVariants(ref).length > 0) return true;
+			return uniqueModelVariants(ref).length === 1;
+		default: return false;
+	}
+}
+/** Check if a type has a format that requires conversion. */
+function hasFormatConversion(ref) {
+	switch (ref.kind) {
+		case "primitive": return ref.format === "date-time" || ref.format === "int64";
+		case "nullable": return hasFormatConversion(ref.inner);
+		default: return false;
+	}
+}
+/** Check if a type specifically has a date-time format conversion. */
+function hasDateTimeConversion(ref) {
+	switch (ref.kind) {
+		case "primitive": return ref.format === "date-time";
+		case "nullable": return hasDateTimeConversion(ref.inner);
+		default: return false;
+	}
+}
+/** Deserialize a primitive value, applying format conversions when needed. */
+function deserializePrimitive(ref, wireExpr) {
+	if (ref.format === "date-time") return `new Date(${wireExpr})`;
+	if (ref.format === "int64") return `BigInt(${wireExpr})`;
+	return wireExpr;
+}
+/** Serialize a primitive value, applying format conversions when needed. */
+function serializePrimitive(ref, domainExpr) {
+	if (ref.format === "date-time") return `${domainExpr}.toISOString()`;
+	if (ref.format === "int64") return `String(${domainExpr})`;
+	return domainExpr;
+}
+/**
+* Render a discriminated union switch expression.
+* Produces an IIFE that switches on the discriminator property and calls
+* the appropriate serializer/deserializer for each mapped model.
+*/
+function renderDiscriminatorSwitch(ref, expr, direction, ctx) {
+	const disc = ref.discriminator;
+	const cases = [];
+	for (const [value, modelName] of Object.entries(disc.mapping)) {
+		const fn = `${direction}${resolveInterfaceName(modelName, ctx)}`;
+		cases.push(`case '${value}': return ${fn}(${expr} as any)`);
+	}
+	return `(() => { switch ((${expr} as any).${disc.property}) { ${cases.join("; ")}; default: return ${expr} } })()`;
+}
+/**
+* Render an allOf merge expression.
+* Spreads the serialized/deserialized result of each model variant.
+*/
+function renderAllOfMerge(ref, expr, direction, ctx) {
+	const models = uniqueModelVariants(ref);
+	if (models.length === 0) return expr;
+	return `({ ${models.map((name) => {
+		return `...${direction}${resolveInterfaceName(name, ctx)}(${expr} as any)`;
+	}).join(", ")} })`;
+}
+/**
+* Return a TypeScript default value expression for a type, used as a null
+* coalesce fallback when a required domain field may be optional in the
+* response interface (baseline override mismatch).
+*/
+function defaultForType(ref) {
+	switch (ref.kind) {
+		case "literal": return typeof ref.value === "string" ? `'${ref.value}'` : String(ref.value);
+		case "enum": return null;
+		case "map": return "{}";
+		case "nullable": return "null";
+		case "primitive": switch (ref.type) {
+			case "boolean": return "false";
+			case "string": return "''";
+			case "integer":
+			case "number": return "0";
+			default: return null;
+		}
+		case "array": return "[]";
+		default: return null;
+	}
+}
+/**
+* Check if the generated serialize function would produce type errors
+* against the baseline wire (response) interface.  Returns true when:
+* - The baseline response interface has required fields whose wire name
+*   doesn't match any IR model field → TS2741 missing property.
+* - The baseline domain interface has required fields whose camelCase name
+*   doesn't match any IR model field → the serializer would produce
+*   expressions referencing domain fields that don't exist on the baseline.
+* - The baseline response has a required array field whose type references
+*   a different module than where the serializer imports its nested serializer.
+*/
+function serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx) {
+	if (!baselineResponse?.fields) return false;
+	const irWireFields = /* @__PURE__ */ new Set();
+	const irDomainFields = /* @__PURE__ */ new Set();
+	for (const field of model.fields) {
+		irWireFields.add(wireFieldName(field.name));
+		irDomainFields.add(fieldName(field.name));
+	}
+	for (const [wireField2, fieldDef] of Object.entries(baselineResponse.fields)) {
+		if (fieldDef.optional) continue;
+		if (!irWireFields.has(wireField2)) return true;
+	}
+	if (baselineDomain?.fields) {
+		const baselineRequiredFields = Object.entries(baselineDomain.fields).filter(([, f]) => !f.optional).map(([name]) => name);
+		const unmatchedCount = baselineRequiredFields.filter((n) => !irDomainFields.has(n)).length;
+		if (unmatchedCount > 0 && baselineRequiredFields.length > 0) {
+			if (unmatchedCount / baselineRequiredFields.length > .3) return true;
+		}
+	}
+	if (ctx?.apiSurface?.interfaces) {
+		const modelSourceFile = baselineResponse?.sourceFile;
+		const responseDir = modelSourceFile ? modelSourceFile.split("/").slice(0, 2).join("/") : null;
+		for (const field of model.fields) {
+			let fieldType = field.type;
+			if (fieldType.kind === "nullable") fieldType = fieldType.inner;
+			if (fieldType.kind !== "array" && fieldType.kind !== "model") continue;
+			const innerType = fieldType.kind === "array" ? fieldType.items : fieldType;
+			if (innerType.kind !== "model") continue;
+			const nestedWireName = wireInterfaceName(resolveInterfaceName(innerType.name, ctx));
+			const wireField3 = wireFieldName(field.name);
+			const baselineWireField2 = baselineResponse.fields[wireField3];
+			if (!baselineWireField2) continue;
+			const baselineTypeNames = baselineWireField2.type.match(/\b[A-Z][a-zA-Z0-9]*Response\b/g) || [];
+			if (baselineTypeNames.length > 0 && !baselineTypeNames.includes(nestedWireName)) return true;
+			if (baselineWireField2.type.includes(nestedWireName) || baselineWireField2.type.match(/\b[A-Z]\w*Response\b/)) {
+				const typeNames = baselineWireField2.type.match(/\b[A-Z][a-zA-Z0-9]*\b/g) || [];
+				for (const typeName of typeNames) {
+					if (typeName === "Record" || typeName === "Array") continue;
+					const nestedIface = ctx.apiSurface.interfaces[typeName];
+					if (!nestedIface) continue;
+					const nestedSrc = nestedIface.sourceFile;
+					if (!nestedSrc || !responseDir) continue;
+					if (nestedSrc.split("/").slice(0, 2).join("/") !== responseDir) return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+//#endregion
+//#region src/node/fixtures.ts
+/**
+* Prefix mapping for generating realistic ID fixture values.
+* When a field named "id" belongs to a model whose name matches a key here,
+* the generated ID will be prefixed accordingly (e.g. "conn_01234").
+*/
+const ID_PREFIXES = {
+	Connection: "conn_",
+	Organization: "org_",
+	OrganizationMembership: "om_",
+	User: "user_",
+	Directory: "directory_",
+	DirectoryGroup: "dir_grp_",
+	DirectoryUser: "dir_usr_",
+	Invitation: "inv_",
+	Session: "session_",
+	AuthenticationFactor: "auth_factor_",
+	EmailVerification: "email_verification_",
+	MagicAuth: "magic_auth_",
+	PasswordReset: "password_reset_"
+};
+/**
+* Generate JSON fixture files for test data.
+* Each model that appears as a response gets a fixture in wire format (snake_case).
+*/
+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"
+	};
+	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
+	const files = [];
+	for (const model of spec.models) {
+		if (isListMetadataModel(model)) continue;
+		if (isListWrapperModel(model)) continue;
+		const dirName = resolveDir(modelToService.get(model.name));
+		const fixture = generateModelFixture(model, modelMap, enumMap);
+		files.push({
+			path: `src/${dirName}/fixtures/${fileName(model.name)}.fixture.json`,
+			content: JSON.stringify(fixture, null, 2)
+		});
+	}
+	for (const service of spec.services) {
+		const serviceDir = serviceDirName(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) {
+				const unwrapped = unwrapListModel(itemModel, modelMap);
+				if (unwrapped) itemModel = unwrapped;
+				const listFixture = {
+					data: [generateModelFixture(itemModel, modelMap, enumMap)],
+					list_metadata: {
+						before: null,
+						after: null
+					}
+				};
+				files.push({
+					path: `src/${serviceDir}/fixtures/list-${fileName(itemModel.name)}.fixture.json`,
+					content: JSON.stringify(listFixture, null, 2)
+				});
+			}
+		}
+	}
+	return files;
+}
+/**
+* Detect if a model is a list wrapper (has a `data` array field and a `list_metadata` field).
+* If so, return the inner item model from the `data` array. Otherwise return null.
+* This prevents double-nesting when the pagination itemType points to a list wrapper
+* instead of the actual item model.
+*/
+function unwrapListModel(model, modelMap) {
+	const dataField = model.fields.find((f) => f.name === "data");
+	const hasListMetadata = model.fields.some((f) => f.name === "list_metadata" || f.name === "listMetadata");
+	if (dataField && hasListMetadata && dataField.type.kind === "array") {
+		const itemType = dataField.type.items;
+		if (itemType.kind === "model") return modelMap.get(itemType.name) ?? null;
+	}
+	return null;
+}
+function generateModelFixture(model, modelMap, enumMap) {
+	const fixture = {};
+	for (const field of model.fields) {
+		const wireName = wireFieldName(field.name);
+		if (field.example !== void 0) fixture[wireName] = field.example;
+		else fixture[wireName] = generateFieldValue(field.type, field.name, model.name, modelMap, enumMap);
+	}
+	return fixture;
+}
+function generateFieldValue(ref, fieldName, modelName, modelMap, enumMap) {
+	switch (ref.kind) {
+		case "primitive": return generatePrimitiveValue(ref.type, ref.format, fieldName, modelName);
+		case "literal": return ref.value;
+		case "enum": return enumMap.get(ref.name)?.values[0]?.value ?? "unknown";
+		case "model": {
+			const nested = modelMap.get(ref.name);
+			if (nested) return generateModelFixture(nested, modelMap, enumMap);
+			return {};
+		}
+		case "array":
+			if (ref.items.kind === "enum") {
+				const e = enumMap.get(ref.items.name);
+				if (e && e.values.length > 0) return e.values.map((v) => v.value);
+			}
+			return [generateFieldValue(ref.items, fieldName, modelName, modelMap, enumMap)];
+		case "nullable": return generateFieldValue(ref.inner, fieldName, modelName, modelMap, enumMap);
+		case "union":
+			if (ref.variants.length > 0) return generateFieldValue(ref.variants[0], fieldName, modelName, modelMap, enumMap);
+			return null;
+		case "map": return { key: generateFieldValue(ref.valueType, "value", modelName, modelMap, enumMap) };
+	}
+}
+function generatePrimitiveValue(type, format, name, modelName) {
+	switch (type) {
+		case "string":
+			if (format === "date-time") return "2023-01-01T00:00:00.000Z";
+			if (format === "date") return "2023-01-01";
+			if (format === "uuid") return "00000000-0000-0000-0000-000000000000";
+			if (name === "id") return `${ID_PREFIXES[modelName] ?? ""}01234`;
+			if (name.includes("id")) return `${name}_01234`;
+			if (name.includes("email")) return "test@example.com";
+			if (name.includes("url") || name.includes("uri")) return "https://example.com";
+			if (name.includes("name")) return "Test";
+			return `test_${name}`;
+		case "integer": return 1;
+		case "number": return 1;
+		case "boolean": return true;
+		case "unknown": return {};
+		default: return null;
+	}
+}
+//#endregion
+//#region src/node/resources.ts
+/**
+* Check whether the baseline (hand-written) class has a constructor compatible
+* with the generated pattern `constructor(private readonly workos: WorkOS)`.
+* Returns true when no baseline exists (fresh generation) or when compatible.
+*/
+function hasCompatibleConstructor(className, ctx) {
+	const baselineClass = ctx.apiSurface?.classes?.[className];
+	if (!baselineClass) return true;
+	const params = baselineClass.constructorParams;
+	if (!params || params.length === 0) return true;
+	return params.some((p) => p.name === "workos" && p.type.includes("WorkOS"));
+}
+/**
+* Resolve the resource class name for a service, accounting for constructor
+* compatibility with the baseline class.
+*
+* When the overlay-resolved class has an incompatible constructor (e.g., a
+* hand-written `Webhooks` class that takes `CryptoProvider` instead of `WorkOS`),
+* falls back to the IR name (`toPascalCase(service.name)`). If the IR name
+* collides with the overlay name, appends an `Endpoints` suffix.
+*/
+function resolveResourceClassName(service, ctx) {
+	const overlayName = resolveServiceName(service, ctx);
+	if (hasCompatibleConstructor(overlayName, ctx)) return overlayName;
+	const irName = toPascalCase(service.name);
+	if (irName === overlayName) return irName + "Endpoints";
+	return irName;
+}
+/** Standard pagination query params handled by PaginationOptions — not imported individually. */
+const PAGINATION_PARAM_NAMES = new Set([
+	"limit",
+	"before",
+	"after",
+	"order"
+]);
+/** Map HTTP status codes to their corresponding exception class names for @throws docs. */
+const STATUS_TO_EXCEPTION_NAME = {
+	400: "BadRequestException",
+	401: "UnauthorizedException",
+	404: "NotFoundException",
+	409: "ConflictException",
+	422: "UnprocessableEntityException",
+	429: "RateLimitExceededException"
+};
+/**
+* Compute the options interface name for a paginated method.
+* When the method name is simply "list", prefix with the service name to avoid
+* naming collisions at barrel-export level (e.g. "ConnectionsListOptions"
+* instead of the generic "ListOptions").
+*/
+function paginatedOptionsName(method, resolvedServiceName) {
+	if (method === "list") return `${toPascalCase(resolvedServiceName)}ListOptions`;
+	return toPascalCase(method) + "Options";
+}
+/** HTTP methods that require a body argument even when the spec has no request body. */
+function httpMethodNeedsBody(method) {
+	return method === "post" || method === "put" || method === "patch";
+}
+function generateResources(services, ctx) {
+	if (services.length === 0) return [];
+	const files = [];
+	for (const service of services) {
+		if (isServiceCoveredByExisting(service, ctx)) continue;
+		const ops = uncoveredOperations(service, ctx);
+		if (ops.length === 0) continue;
+		if (ops.length < service.operations.length) {
+			const file = generateResourceClass({
+				...service,
+				operations: ops
+			}, ctx);
+			delete file.skipIfExists;
+			files.push(file);
+		} else files.push(generateResourceClass(service, ctx));
+	}
+	return files;
+}
+function generateResourceClass(service, ctx) {
+	const resolvedName = resolveResourceClassName(service, ctx);
+	const serviceDir = serviceDirName(resolvedName);
+	const serviceClass = resolvedName;
+	const resourcePath = `src/${serviceDir}/${fileName(resolvedName)}.ts`;
+	const plans = service.operations.map((op) => ({
+		op,
+		plan: planOperation(op),
+		method: resolveMethodName(op, service, ctx)
+	}));
+	if (ctx.overlayLookup?.methodByOperation) {
+		const methodOrder = /* @__PURE__ */ new Map();
+		let pos = 0;
+		for (const [, info] of ctx.overlayLookup.methodByOperation) if (!methodOrder.has(info.methodName)) methodOrder.set(info.methodName, pos++);
+		if (methodOrder.size > 0) plans.sort((a, b) => {
+			return (methodOrder.get(a.method) ?? Number.MAX_SAFE_INTEGER) - (methodOrder.get(b.method) ?? Number.MAX_SAFE_INTEGER);
+		});
+	}
+	const hasPaginated = plans.some((p) => p.plan.isPaginated);
+	const modelMap = new Map(ctx.spec.models.map((m) => [m.name, m]));
+	const responseModels = /* @__PURE__ */ new Set();
+	const requestModels = /* @__PURE__ */ new Set();
+	const paramEnums = /* @__PURE__ */ new Set();
+	const paramModels = /* @__PURE__ */ new Set();
+	for (const { op, plan } of plans) {
+		if (plan.isPaginated && op.pagination?.itemType.kind === "model") {
+			let itemName = op.pagination.itemType.name;
+			const itemModel = modelMap.get(itemName);
+			if (itemModel) {
+				const unwrapped = unwrapListModel(itemModel, modelMap);
+				if (unwrapped) itemName = unwrapped.name;
+			}
+			responseModels.add(itemName);
+		} else if (plan.responseModelName) responseModels.add(plan.responseModelName);
+		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);
+		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);
+	}
+	const allModels = new Set([
+		...responseModels,
+		...requestModels,
+		...paramModels
+	]);
+	const lines = [];
+	lines.push("import type { WorkOS } from '../workos';");
+	if (hasPaginated) {
+		lines.push("import type { PaginationOptions } from '../common/interfaces/pagination-options.interface';");
+		lines.push("import type { AutoPaginatable } from '../common/utils/pagination';");
+		lines.push("import { createPaginatedList } from '../common/utils/fetch-and-deserialize';");
+	}
+	const hasIdempotentPost = plans.some((p) => p.plan.isIdempotentPost);
+	const hasCustomEncoding = plans.some((p) => p.op.requestBodyEncoding && p.op.requestBodyEncoding !== "json" && p.plan.hasBody);
+	if (hasIdempotentPost || hasCustomEncoding) lines.push("import type { PostOptions } from '../common/interfaces/post-options.interface';");
+	const { modelToService, resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
+	const usedWireTypes = /* @__PURE__ */ new Set();
+	for (const name of responseModels) usedWireTypes.add(resolveInterfaceName(name, ctx));
+	const importedTypeNames = /* @__PURE__ */ new Set();
+	for (const name of allModels) {
+		const resolved = resolveInterfaceName(name, ctx);
+		if (importedTypeNames.has(resolved)) continue;
+		importedTypeNames.add(resolved);
+		const modelServiceDir = resolveDir(modelToService.get(name));
+		const relPath = modelServiceDir === serviceDir ? `./interfaces/${fileName(name)}.interface` : `../${modelServiceDir}/interfaces/${fileName(name)}.interface`;
+		if (usedWireTypes.has(resolved)) lines.push(`import type { ${resolved}, ${wireInterfaceName(resolved)} } from '${relPath}';`);
+		else lines.push(`import type { ${resolved} } from '${relPath}';`);
+	}
+	const serializerImportsByPath = /* @__PURE__ */ new Map();
+	const importedDeserializers = /* @__PURE__ */ new Set();
+	for (const name of responseModels) {
+		const resolved = resolveInterfaceName(name, ctx);
+		if (importedDeserializers.has(resolved)) continue;
+		importedDeserializers.add(resolved);
+		const modelServiceDir = resolveDir(modelToService.get(name));
+		const relPath = modelServiceDir === serviceDir ? `./serializers/${fileName(name)}.serializer` : `../${modelServiceDir}/serializers/${fileName(name)}.serializer`;
+		const existing = serializerImportsByPath.get(relPath) ?? [];
+		existing.push(`deserialize${resolved}`);
+		serializerImportsByPath.set(relPath, existing);
+	}
+	const importedSerializers = /* @__PURE__ */ new Set();
+	for (const name of requestModels) {
+		const resolved = resolveInterfaceName(name, ctx);
+		if (importedSerializers.has(resolved)) continue;
+		importedSerializers.add(resolved);
+		const modelServiceDir = resolveDir(modelToService.get(name));
+		const relPath = modelServiceDir === serviceDir ? `./serializers/${fileName(name)}.serializer` : `../${modelServiceDir}/serializers/${fileName(name)}.serializer`;
+		const existing = serializerImportsByPath.get(relPath) ?? [];
+		existing.push(`serialize${resolved}`);
+		serializerImportsByPath.set(relPath, existing);
+	}
+	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(ctx.spec.enums, ctx.spec.services);
+		for (const name of paramEnums) {
+			if (allModels.has(name)) continue;
+			if (!specEnumNames.has(name)) continue;
+			const enumServiceDir = resolveDir(enumToService.get(name));
+			const relPath = enumServiceDir === serviceDir ? `./interfaces/${fileName(name)}.interface` : `../${enumServiceDir}/interfaces/${fileName(name)}.interface`;
+			lines.push(`import type { ${name} } from '${relPath}';`);
+		}
+	}
+	lines.push("");
+	for (const { op, plan, method } of plans) if (plan.isPaginated) {
+		const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
+		if (extraParams.length > 0) {
+			const optionsName = paginatedOptionsName(method, resolvedName);
+			lines.push(`export interface ${optionsName} extends PaginationOptions {`);
+			for (const param of extraParams) {
+				const opt = !param.required ? "?" : "";
+				if (param.description || param.deprecated) {
+					const parts = [];
+					if (param.description) parts.push(param.description);
+					if (param.deprecated) parts.push("@deprecated");
+					lines.push(...docComment(parts.join("\n"), 2));
+				}
+				lines.push(`  ${fieldName(param.name)}${opt}: ${mapParamType(param.type, specEnumNames)};`);
+			}
+			lines.push("}");
+			lines.push("");
+		}
+	} else if (!plan.isPaginated && !plan.hasBody && !plan.isDelete && op.queryParams.length > 0) {
+		const optionsName = toPascalCase(method) + "Options";
+		lines.push(`export interface ${optionsName} {`);
+		for (const param of op.queryParams) {
+			const opt = !param.required ? "?" : "";
+			if (param.description || param.deprecated) {
+				const parts = [];
+				if (param.description) parts.push(param.description);
+				if (param.deprecated) parts.push("@deprecated");
+				lines.push(...docComment(parts.join("\n"), 2));
+			}
+			lines.push(`  ${fieldName(param.name)}${opt}: ${mapParamType(param.type, specEnumNames)};`);
+		}
+		lines.push("}");
+		lines.push("");
+	}
+	if (service.description) lines.push(...docComment(service.description));
+	lines.push(`export class ${serviceClass} {`);
+	lines.push("  constructor(private readonly workos: WorkOS) {}");
+	for (const { op, plan, method } of plans) {
+		lines.push("");
+		lines.push(...renderMethod(op, plan, method, service, ctx, modelMap, specEnumNames));
+	}
+	lines.push("}");
+	return {
+		path: resourcePath,
+		content: lines.join("\n"),
+		skipIfExists: true
+	};
+}
+function renderMethod(op, plan, method, service, ctx, modelMap, specEnumNames) {
+	const lines = [];
+	const responseModel = plan.responseModelName ? resolveInterfaceName(plan.responseModelName, ctx) : null;
+	const pathStr = buildPathStr(op);
+	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+	const overlayMethod = ctx.overlayLookup?.methodByOperation?.get(httpKey);
+	let validParamNames = null;
+	if (overlayMethod) validParamNames = new Set(overlayMethod.params.map((p) => p.name));
+	else {
+		const actualParams = /* @__PURE__ */ new Set();
+		for (const p of op.pathParams) actualParams.add(fieldName(p.name));
+		if (plan.hasBody) actualParams.add("payload");
+		if (plan.isPaginated) actualParams.add("options");
+		if (!plan.isPaginated && op.queryParams.length > 0 && !plan.isDelete && responseModel) actualParams.add("options");
+		validParamNames = actualParams;
+	}
+	const docParts = [];
+	if (op.description) docParts.push(op.description);
+	for (const param of op.pathParams) {
+		const paramName = fieldName(param.name);
+		if (validParamNames && !validParamNames.has(paramName)) continue;
+		const deprecatedPrefix = param.deprecated ? "(deprecated) " : "";
+		if (param.description) docParts.push(`@param ${paramName} - ${deprecatedPrefix}${param.description}`);
+		else if (param.deprecated) docParts.push(`@param ${paramName} - (deprecated)`);
+		if (param.default !== void 0) docParts.push(`@default ${JSON.stringify(param.default)}`);
+		if (param.example !== void 0) docParts.push(`@example ${JSON.stringify(param.example)}`);
+	}
+	if (!plan.isPaginated) {
+		if (validParamNames && (validParamNames.has("options") || overlayMethod)) for (const param of op.queryParams) {
+			const paramName = `options.${fieldName(param.name)}`;
+			if (validParamNames && !validParamNames.has("options") && !validParamNames.has(fieldName(param.name))) continue;
+			const deprecatedPrefix = param.deprecated ? "(deprecated) " : "";
+			if (param.description) docParts.push(`@param ${paramName} - ${deprecatedPrefix}${param.description}`);
+			else if (param.deprecated) docParts.push(`@param ${paramName} - (deprecated)`);
+			if (param.default !== void 0) docParts.push(`@default ${JSON.stringify(param.default)}`);
+			if (param.example !== void 0) docParts.push(`@example ${JSON.stringify(param.example)}`);
+		}
+	}
+	if (plan.hasBody) {
+		const bodyInfo = extractRequestBodyType(op, ctx);
+		if (bodyInfo?.kind === "model") {
+			const bodyModel = ctx.spec.models.find((m) => m.name === bodyInfo.name);
+			let payloadDesc;
+			if (bodyModel?.description) payloadDesc = `@param payload - ${bodyModel.description}`;
+			else if (bodyModel) {
+				const requiredFieldNames = bodyModel.fields.filter((f) => f.required).map((f) => fieldName(f.name));
+				payloadDesc = requiredFieldNames.length > 0 ? `@param payload - Object containing ${requiredFieldNames.join(", ")}.` : "@param payload - The request body.";
+			} else payloadDesc = "@param payload - The request body.";
+			docParts.push(payloadDesc);
+		} else docParts.push("@param payload - The request body.");
+	}
+	if (plan.isPaginated) docParts.push("@param options - Pagination and filter options.");
+	else if (op.queryParams.length > 0) docParts.push("@param options - Additional query options.");
+	if (plan.isPaginated && op.pagination?.itemType.kind === "model") {
+		let itemRawName = op.pagination.itemType.name;
+		const pModel = modelMap.get(itemRawName);
+		if (pModel) {
+			const unwrapped = unwrapListModel(pModel, modelMap);
+			if (unwrapped) itemRawName = unwrapped.name;
+		}
+		const itemTypeName = resolveInterfaceName(itemRawName, ctx);
+		docParts.push(`@returns {AutoPaginatable<${itemTypeName}>}`);
+	} else if (responseModel) docParts.push(`@returns {${responseModel}}`);
+	else docParts.push("@returns {void}");
+	for (const err of op.errors) {
+		const exceptionName = STATUS_TO_EXCEPTION_NAME[err.statusCode];
+		if (exceptionName) docParts.push(`@throws {${exceptionName}} ${err.statusCode}`);
+	}
+	if (op.deprecated) docParts.push("@deprecated");
+	if (docParts.length > 0) {
+		const allLines = [];
+		for (const part of docParts) for (const line of part.split("\n")) allLines.push(line);
+		if (allLines.length === 1) lines.push(`  /** ${allLines[0]} */`);
+		else {
+			lines.push("  /**");
+			for (const line of allLines) lines.push(line === "" ? "   *" : `   * ${line}`);
+			lines.push("   */");
+		}
+	}
+	const preDecisionCount = lines.length;
+	if (plan.isPaginated && op.pagination && op.httpMethod === "get") {
+		let paginatedItemRawName = op.pagination.itemType.kind === "model" ? op.pagination.itemType.name : null;
+		if (paginatedItemRawName) {
+			const pModel = modelMap.get(paginatedItemRawName);
+			if (pModel) {
+				const unwrapped = unwrapListModel(pModel, modelMap);
+				if (unwrapped) paginatedItemRawName = unwrapped.name;
+			}
+		}
+		const paginatedItemType = paginatedItemRawName ? resolveInterfaceName(paginatedItemRawName, ctx) : responseModel;
+		if (paginatedItemType) renderPaginatedMethod(lines, op, plan, method, paginatedItemType, pathStr, resolveServiceName(service, ctx), specEnumNames);
+	} else if (plan.isPaginated && plan.hasBody && responseModel) renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx, specEnumNames);
+	else if (plan.isDelete && plan.hasBody) renderDeleteWithBodyMethod(lines, op, plan, method, pathStr, ctx, specEnumNames);
+	else if (plan.isDelete) renderDeleteMethod(lines, op, plan, method, pathStr, specEnumNames);
+	else if (plan.hasBody && responseModel) renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx, specEnumNames);
+	else if (responseModel) renderGetMethod(lines, op, plan, method, responseModel, pathStr, specEnumNames);
+	else renderVoidMethod(lines, op, plan, method, pathStr, ctx, specEnumNames);
+	if (lines.length === preDecisionCount) {
+		const params = buildPathParams(op, specEnumNames);
+		lines.push(`  async ${method}(${params}): Promise<void> {`);
+		lines.push(`    await this.workos.${op.httpMethod}(${pathStr}${httpMethodNeedsBody(op.httpMethod) ? ", {}" : ""});`);
+		lines.push("  }");
+	}
+	return lines;
+}
+function renderPaginatedMethod(lines, op, plan, method, itemType, pathStr, resolvedServiceName, specEnumNames) {
+	const optionsType = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name)).length > 0 ? paginatedOptionsName(method, resolvedServiceName) : "PaginationOptions";
+	const pathParams = buildPathParams(op, specEnumNames);
+	const allParams = pathParams ? `${pathParams}, options?: ${optionsType}` : `options?: ${optionsType}`;
+	lines.push(`  async ${method}(${allParams}): Promise<AutoPaginatable<${itemType}, ${optionsType}>> {`);
+	lines.push(`    return createPaginatedList<${wireInterfaceName(itemType)}, ${itemType}, ${optionsType}>(this.workos, ${pathStr}, deserialize${itemType}, options);`);
+	lines.push("  }");
+}
+function renderDeleteMethod(lines, op, plan, method, pathStr, specEnumNames) {
+	const params = buildPathParams(op, specEnumNames);
+	lines.push(`  async ${method}(${params}): Promise<void> {`);
+	lines.push(`    await this.workos.delete(${pathStr});`);
+	lines.push("  }");
+}
+function renderDeleteWithBodyMethod(lines, op, plan, method, pathStr, ctx, specEnumNames) {
+	const bodyInfo = extractRequestBodyType(op, ctx);
+	let requestType;
+	let bodyExpr;
+	if (bodyInfo?.kind === "model") {
+		requestType = resolveInterfaceName(bodyInfo.name, ctx);
+		bodyExpr = `serialize${requestType}(payload)`;
+	} else if (bodyInfo?.kind === "union") {
+		requestType = bodyInfo.typeStr;
+		if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
+		else bodyExpr = "payload";
+	} else {
+		requestType = "Record<string, unknown>";
+		bodyExpr = "payload";
+	}
+	const paramParts = [];
+	for (const param of op.pathParams) paramParts.push(`${fieldName(param.name)}: ${specEnumNames ? mapParamType(param.type, specEnumNames) : mapTypeRef$1(param.type)}`);
+	paramParts.push(`payload: ${requestType}`);
+	lines.push(`  async ${method}(${paramParts.join(", ")}): Promise<void> {`);
+	lines.push(`    await this.workos.deleteWithBody(${pathStr}, ${bodyExpr});`);
+	lines.push("  }");
+}
+function renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx, specEnumNames) {
+	const bodyInfo = extractRequestBodyType(op, ctx);
+	let requestType;
+	let bodyExpr;
+	if (bodyInfo?.kind === "model") {
+		requestType = resolveInterfaceName(bodyInfo.name, ctx);
+		bodyExpr = `serialize${requestType}(payload)`;
+	} else if (bodyInfo?.kind === "union") {
+		requestType = bodyInfo.typeStr;
+		if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
+		else bodyExpr = "payload";
+	} else {
+		requestType = "Record<string, unknown>";
+		bodyExpr = "payload";
+	}
+	const paramParts = [];
+	for (const param of op.pathParams) paramParts.push(`${fieldName(param.name)}: ${specEnumNames ? mapParamType(param.type, specEnumNames) : mapTypeRef$1(param.type)}`);
+	paramParts.push(`payload: ${requestType}`);
+	if (plan.isIdempotentPost) paramParts.push("requestOptions: PostOptions = {}");
+	const paramsStr = paramParts.join(", ");
+	const encoding = op.requestBodyEncoding;
+	const encodingOption = encoding && encoding !== "json" ? `, encoding: '${encoding}' as const` : "";
+	const hasCustomEncoding = encodingOption !== "";
+	lines.push(`  async ${method}(${paramsStr}): Promise<${responseModel}> {`);
+	if (plan.isIdempotentPost) if (hasCustomEncoding) {
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
+		lines.push(`      ${pathStr},`);
+		lines.push(`      ${bodyExpr},`);
+		lines.push(`      { ...requestOptions${encodingOption} },`);
+		lines.push("    );");
+	} else {
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
+		lines.push(`      ${pathStr},`);
+		lines.push(`      ${bodyExpr},`);
+		lines.push("      requestOptions,");
+		lines.push("    );");
+	}
+	else if (hasCustomEncoding) {
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
+		lines.push(`      ${pathStr},`);
+		lines.push(`      ${bodyExpr},`);
+		lines.push(`      { ${encodingOption.slice(2)} },`);
+		lines.push("    );");
+	} else {
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
+		lines.push(`      ${pathStr},`);
+		lines.push(`      ${bodyExpr},`);
+		lines.push("    );");
+	}
+	lines.push(`    return deserialize${responseModel}(data);`);
+	lines.push("  }");
+}
+function renderGetMethod(lines, op, plan, method, responseModel, pathStr, specEnumNames) {
+	const params = buildPathParams(op, specEnumNames);
+	const hasQuery = op.queryParams.length > 0 && !plan.isPaginated;
+	const optionsType = hasQuery ? toPascalCase(method) + "Options" : null;
+	const allParams = hasQuery ? params ? `${params}, options?: ${optionsType}` : `options?: ${optionsType}` : params;
+	lines.push(`  async ${method}(${allParams}): Promise<${responseModel}> {`);
+	if (hasQuery) {
+		const queryExpr = renderQueryExpr(op.queryParams);
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(${pathStr}, {`);
+		lines.push(`      query: ${queryExpr},`);
+		lines.push("    });");
+	} else if (httpMethodNeedsBody(op.httpMethod)) lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(${pathStr}, {});`);
+	else lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(${pathStr});`);
+	lines.push(`    return deserialize${responseModel}(data);`);
+	lines.push("  }");
+}
+function renderVoidMethod(lines, op, plan, method, pathStr, ctx, specEnumNames) {
+	const params = buildPathParams(op, specEnumNames);
+	const hasQuery = op.queryParams.length > 0 && !plan.hasBody;
+	const optionsType = hasQuery ? toPascalCase(method) + "Options" : null;
+	let bodyParam = "";
+	let bodyExpr = "payload";
+	if (plan.hasBody) {
+		const bodyInfo = extractRequestBodyType(op, ctx);
+		if (bodyInfo?.kind === "model") {
+			const requestType = resolveInterfaceName(bodyInfo.name, ctx);
+			bodyParam = `payload: ${requestType}`;
+			bodyExpr = `serialize${requestType}(payload)`;
+		} else if (bodyInfo?.kind === "union") {
+			bodyParam = `payload: ${bodyInfo.typeStr}`;
+			if (bodyInfo.discriminator) bodyExpr = renderUnionBodySerializer(bodyInfo.discriminator, ctx);
+			else bodyExpr = "payload";
+		} else {
+			bodyParam = "payload: Record<string, unknown>";
+			bodyExpr = "payload";
+		}
+	}
+	const paramParts = [];
+	if (params) paramParts.push(params);
+	if (bodyParam) paramParts.push(bodyParam);
+	if (optionsType) paramParts.push(`options?: ${optionsType}`);
+	const allParams = paramParts.join(", ");
+	lines.push(`  async ${method}(${allParams}): Promise<void> {`);
+	if (plan.hasBody) lines.push(`    await this.workos.${op.httpMethod}(${pathStr}, ${bodyExpr});`);
+	else if (hasQuery) {
+		const queryExpr = renderQueryExpr(op.queryParams);
+		lines.push(`    await this.workos.${op.httpMethod}(${pathStr}, {`);
+		lines.push(`      query: ${queryExpr},`);
+		lines.push("    });");
+	} else if (httpMethodNeedsBody(op.httpMethod)) lines.push(`    await this.workos.${op.httpMethod}(${pathStr}, {});`);
+	else lines.push(`    await this.workos.${op.httpMethod}(${pathStr});`);
+	lines.push("  }");
+}
+/**
+* Generate an inline query serialization expression that maps camelCase option
+* keys to their snake_case wire equivalents.  When all keys already match
+* (camel === snake), returns 'options' as-is for brevity.
+*/
+function renderQueryExpr(queryParams) {
+	if (!queryParams.some((p) => fieldName(p.name) !== wireFieldName(p.name))) return "options";
+	const parts = [];
+	for (const param of queryParams) {
+		const camel = fieldName(param.name);
+		const snake = wireFieldName(param.name);
+		if (param.required) parts.push(`${snake}: options.${camel}`);
+		else parts.push(`...(options.${camel} !== undefined && { ${snake}: options.${camel} })`);
+	}
+	return `options ? { ${parts.join(", ")} } : undefined`;
+}
+function buildPathStr(op) {
+	const interpolated = op.path.replace(/\{(\w+)\}/g, (_, p) => `\${${fieldName(p)}}`);
+	return interpolated.includes("${") ? `\`${interpolated}\`` : `'${op.path}'`;
+}
+function buildPathParams(op, specEnumNames) {
+	const declaredNames = new Set(op.pathParams.map((p) => fieldName(p.name)));
+	const params = op.pathParams.map((p) => {
+		const type = specEnumNames ? mapParamType(p.type, specEnumNames) : mapTypeRef$1(p.type);
+		return `${fieldName(p.name)}: ${type}`;
+	});
+	const templateVars = [...op.path.matchAll(/\{(\w+)\}/g)].map(([, name]) => fieldName(name));
+	for (const varName of templateVars) if (!declaredNames.has(varName)) params.push(`${varName}: string`);
+	return params.join(", ");
+}
+/**
+* Walk a parameter's type tree and collect enum/model names for imports.
+* Handles arrays and nullable wrappers that may contain nested enums/models.
+*/
+function collectParamTypeRefs(type, enums, models) {
+	switch (type.kind) {
+		case "enum":
+			enums.add(type.name);
+			break;
+		case "model":
+			models.add(type.name);
+			break;
+		case "array":
+			collectParamTypeRefs(type.items, enums, models);
+			break;
+		case "nullable":
+			collectParamTypeRefs(type.inner, enums, models);
+			break;
+	}
+}
+/**
+* Extract request body type info, supporting both single models and union types.
+* Returns structured info so callers can handle imports and serialization appropriately.
+*/
+/**
+* Generate an IIFE expression that dispatches to the correct serializer for a
+* discriminated union request body.  Switches on the camelCase discriminator
+* property of the domain object and calls the appropriate serialize function
+* for each mapped model variant.
+*/
+function renderUnionBodySerializer(disc, ctx) {
+	const prop = fieldName(disc.property);
+	const cases = [];
+	for (const [value, modelName] of Object.entries(disc.mapping)) {
+		const resolved = resolveInterfaceName(modelName, ctx);
+		cases.push(`case '${value}': return serialize${resolved}(payload as any)`);
+	}
+	return `(() => { switch ((payload as any).${prop}) { ${cases.join("; ")}; default: return payload } })()`;
+}
+function extractRequestBodyType(op, ctx) {
+	if (!op.requestBody) return null;
+	if (op.requestBody.kind === "model") return {
+		kind: "model",
+		name: op.requestBody.name
+	};
+	if (op.requestBody.kind === "union") {
+		const modelNames = [];
+		for (const variant of op.requestBody.variants) if (variant.kind === "model") modelNames.push(variant.name);
+		if (modelNames.length > 0) return {
+			kind: "union",
+			typeStr: modelNames.map((n) => resolveInterfaceName(n, ctx)).join(" | "),
+			modelNames,
+			discriminator: op.requestBody.discriminator
+		};
+	}
+	return null;
+}
+/**
+* Map a parameter type to a TypeScript type string, handling inline enums
+* that don't have corresponding global enum definitions.  These would
+* otherwise emit bare names like `Type` or `Action` that are never imported.
+*
+* Recursively handles container types (arrays, nullable) so that inline
+* enums nested inside e.g. `array<enum>` are also inlined as string literal unions.
+*/
+function mapParamType(type, specEnumNames) {
+	if (type.kind === "enum" && !specEnumNames.has(type.name)) {
+		if (type.values && type.values.length > 0) return type.values.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(" | ");
+		return "string";
+	}
+	if (type.kind === "array") {
+		const inner = mapParamType(type.items, specEnumNames);
+		return inner.includes(" | ") ? `(${inner})[]` : `${inner}[]`;
+	}
+	if (type.kind === "nullable") return `${mapParamType(type.inner, specEnumNames)} | null`;
+	return mapTypeRef$1(type);
+}
+//#endregion
+//#region src/node/client.ts
+function generateClient(spec, ctx) {
+	const files = [];
+	files.push(generateWorkOSClient(spec, ctx));
+	files.push(...generateServiceBarrels(spec, ctx));
+	files.push(generateBarrel(spec, ctx));
+	files.push(generateWorkerBarrel(spec, ctx));
+	files.push(generatePackageJson(ctx));
+	files.push(generateTsConfig());
+	return files;
+}
+function generateWorkOSClient(spec, ctx) {
+	const lines = [];
+	const hasExistingWorkOS = !!ctx.apiSurface?.classes?.["WorkOS"];
+	if (!hasExistingWorkOS) lines.push("import { WorkOSBase } from './common/workos-base';");
+	const coveredServices = /* @__PURE__ */ new Set();
+	for (const service of spec.services) if (isServiceCoveredByExisting(service, ctx)) coveredServices.add(service.name);
+	for (const service of spec.services) {
+		if (coveredServices.has(service.name)) continue;
+		const resolvedName = resolveResourceClassName(service, ctx);
+		const serviceDir = serviceDirName(resolvedName);
+		lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
+	}
+	lines.push("");
+	if (spec.description) lines.push(...docComment(spec.description));
+	const extendsClause = hasExistingWorkOS ? "" : " extends WorkOSBase";
+	lines.push(`export class WorkOS${extendsClause} {`);
+	if (spec.servers && spec.servers.length > 0) {
+		for (const server of spec.servers) {
+			const constName = serverConstName(server.description ?? server.url);
+			if (server.description) lines.push(...docComment(server.description, 2));
+			lines.push(`  static readonly ${constName} = '${server.url}';`);
+		}
+		lines.push("");
+	}
+	const existingProps = /* @__PURE__ */ new Set();
+	const baselineWorkOS = ctx.apiSurface?.classes?.["WorkOS"] ?? ctx.apiSurface?.classes?.["WorkOSNode"];
+	if (baselineWorkOS?.properties) for (const name of Object.keys(baselineWorkOS.properties)) existingProps.add(name);
+	for (const service of spec.services) {
+		if (coveredServices.has(service.name)) continue;
+		const resolvedName = resolveResourceClassName(service, ctx);
+		const propName = servicePropertyName(resolvedName);
+		if (existingProps.has(propName)) continue;
+		lines.push(`  readonly ${propName} = new ${resolvedName}(this);`);
+	}
+	if (needsAuthOverride(spec.auth)) {
+		lines.push("");
+		lines.push("  protected override setAuthHeaders(headers: Record<string, string>): void {");
+		renderAuthOverride(lines, spec.auth);
+		lines.push("  }");
+	}
+	lines.push("}");
+	return {
+		path: "src/workos.ts",
+		content: lines.join("\n"),
+		skipIfExists: true
+	};
+}
+/**
+* Generate per-service barrel files (interfaces/index.ts) that re-export
+* all interface and enum files for each service directory. This reduces
+* the root barrel from ~200+ individual type exports to one wildcard
+* re-export per service.
+*/
+function generateServiceBarrels(spec, ctx) {
+	const files = [];
+	const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+	const dirExports = /* @__PURE__ */ new Map();
+	const dirSymbols = /* @__PURE__ */ new Map();
+	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 (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+			dirSymbols.get(dirName).add(name);
+		}
+	}
+	if (ctx.apiSurface?.enums) for (const [name, enumDef] of Object.entries(ctx.apiSurface.enums)) {
+		const sourceFile = enumDef.sourceFile;
+		if (!sourceFile) continue;
+		const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
+		if (match) {
+			const dirName = match[1];
+			if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+			dirSymbols.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 (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+			dirSymbols.get(dirName).add(name);
+		}
+	}
+	const globalExistingSymbols = /* @__PURE__ */ new Set();
+	for (const symbols of dirSymbols.values()) for (const sym of symbols) globalExistingSymbols.add(sym);
+	for (const model of spec.models) {
+		if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
+		const dirName = resolveDir(modelToService.get(model.name));
+		if (!dirExports.has(dirName)) {
+			dirExports.set(dirName, []);
+			if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+		}
+		const domainName = resolveInterfaceName(model.name, ctx);
+		const wireName = wireInterfaceName(domainName);
+		const symbols = dirSymbols.get(dirName);
+		if (globalExistingSymbols.has(domainName) || globalExistingSymbols.has(wireName)) continue;
+		symbols.add(domainName);
+		symbols.add(wireName);
+		globalExistingSymbols.add(domainName);
+		globalExistingSymbols.add(wireName);
+		dirExports.get(dirName).push(`export * from './${fileName(model.name)}.interface';`);
+	}
+	for (const enumDef of spec.enums) {
+		const dirName = resolveDir(findEnumService(enumDef.name, spec.services));
+		if (!dirExports.has(dirName)) {
+			dirExports.set(dirName, []);
+			if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+		}
+		const symbols = dirSymbols.get(dirName);
+		if (globalExistingSymbols.has(enumDef.name)) continue;
+		symbols.add(enumDef.name);
+		globalExistingSymbols.add(enumDef.name);
+		dirExports.get(dirName).push(`export * from './${fileName(enumDef.name)}.interface';`);
+	}
+	for (const [dirName, exports] of dirExports) {
+		const uniqueExports = [...new Set(exports)];
+		uniqueExports.sort();
+		files.push({
+			path: `src/${dirName}/interfaces/index.ts`,
+			content: uniqueExports.join("\n"),
+			skipIfExists: true
+		});
+	}
+	return files;
+}
+function generateBarrel(spec, ctx) {
+	const lines = [];
+	const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+	const exportedNames = /* @__PURE__ */ new Set();
+	if (ctx.apiSurface?.interfaces) for (const name of Object.keys(ctx.apiSurface.interfaces)) exportedNames.add(name);
+	if (ctx.apiSurface?.classes) for (const name of Object.keys(ctx.apiSurface.classes)) exportedNames.add(name);
+	const existingSdkExports = /* @__PURE__ */ new Set();
+	if (ctx.apiSurface?.exports) for (const names of Object.values(ctx.apiSurface.exports)) for (const name of names) existingSdkExports.add(name);
+	lines.push("export * from './common/exceptions';");
+	lines.push("export { AutoPaginatable } from './common/utils/pagination';");
+	lines.push("export type { List, ListMetadata, ListResponse } from './common/utils/pagination';");
+	lines.push("export type { PaginationOptions } from './common/interfaces/pagination-options.interface';");
+	lines.push("export type { WorkOSOptions } from './common/interfaces/workos-options.interface';");
+	lines.push("export type { PostOptions } from './common/interfaces/post-options.interface';");
+	lines.push("export type { GetOptions } from './common/interfaces/get-options.interface';");
+	lines.push("");
+	for (const name of [
+		"AutoPaginatable",
+		"List",
+		"ListMetadata",
+		"ListResponse",
+		"PaginationOptions",
+		"WorkOSOptions",
+		"PostOptions",
+		"GetOptions"
+	]) exportedNames.add(name);
+	const coveredServicesBarrel = /* @__PURE__ */ new Set();
+	for (const service of spec.services) if (isServiceCoveredByExisting(service, ctx)) coveredServicesBarrel.add(service.name);
+	const exportedDirs = /* @__PURE__ */ new Set();
+	for (const service of spec.services) {
+		const resolvedName = resolveResourceClassName(service, ctx);
+		const serviceDir = serviceDirName(resolvedName);
+		const interfacesDir = resolveDir(service.name);
+		const serviceModels = spec.models.filter((m) => {
+			if (modelToService.get(m.name) !== service.name) return false;
+			if (isListMetadataModel(m) || isListWrapperModel(m)) return false;
+			return true;
+		});
+		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) {
+			exportedDirs.add(interfacesDir);
+			lines.push(`export * from './${interfacesDir}/interfaces';`);
+			for (const model of serviceModels) {
+				exportedNames.add(resolveInterfaceName(model.name, ctx));
+				exportedNames.add(wireInterfaceName(resolveInterfaceName(model.name, ctx)));
+			}
+			for (const enumDef of serviceEnums) exportedNames.add(enumDef.name);
+		} else if (!hasConflict) for (const model of serviceModels) {
+			const name = resolveInterfaceName(model.name, ctx);
+			const wireName = wireInterfaceName(name);
+			if (exportedNames.has(name) || exportedNames.has(wireName)) continue;
+			if (existingSdkExports.has(name)) continue;
+			exportedNames.add(name);
+			exportedNames.add(wireName);
+			lines.push(`export type { ${name}, ${wireName} } from './${interfacesDir}/interfaces/${fileName(model.name)}.interface';`);
+		}
+		if (coveredServicesBarrel.has(service.name)) lines.push(`// ${resolvedName} is covered by an existing hand-written class — not re-exported.`);
+		else if (!exportedNames.has(resolvedName)) {
+			exportedNames.add(resolvedName);
+			lines.push(`export { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
+		}
+		lines.push("");
+	}
+	const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name));
+	const commonEnums = spec.enums.filter((e) => {
+		return !findEnumService(e.name, spec.services);
+	});
+	const commonHasConflict = unassignedModels.some((m) => existingSdkExports.has(resolveInterfaceName(m.name, ctx))) || commonEnums.some((e) => existingSdkExports.has(e.name));
+	if ((unassignedModels.length > 0 || commonEnums.length > 0) && !exportedDirs.has("common") && !commonHasConflict) {
+		exportedDirs.add("common");
+		lines.push("export * from './common/interfaces';");
+		for (const model of unassignedModels) {
+			exportedNames.add(resolveInterfaceName(model.name, ctx));
+			exportedNames.add(wireInterfaceName(resolveInterfaceName(model.name, ctx)));
+		}
+		for (const enumDef of commonEnums) exportedNames.add(enumDef.name);
+	} else for (const model of unassignedModels) {
+		const name = resolveInterfaceName(model.name, ctx);
+		const wireName = wireInterfaceName(name);
+		if (exportedNames.has(name) || exportedNames.has(wireName)) continue;
+		if (existingSdkExports.has(name)) continue;
+		exportedNames.add(name);
+		exportedNames.add(wireName);
+		lines.push(`export type { ${name}, ${wireName} } from './common/interfaces/${fileName(model.name)}.interface';`);
+	}
+	for (const enumDef of spec.enums) {
+		if (exportedNames.has(enumDef.name)) continue;
+		if (existingSdkExports.has(enumDef.name)) continue;
+		exportedNames.add(enumDef.name);
+		const dir = resolveDir(findEnumService(enumDef.name, spec.services));
+		if (!exportedDirs.has(dir)) {
+			const exportKeyword = (ctx.apiSurface?.enums?.[enumDef.name])?.members ? "export" : "export type";
+			lines.push(`${exportKeyword} { ${enumDef.name} } from './${dir}/interfaces/${fileName(enumDef.name)}.interface';`);
+		}
+	}
+	lines.push("");
+	if (!ctx.apiSurface && !exportedNames.has("WorkOS")) {
+		exportedNames.add("WorkOS");
+		lines.push("export { WorkOS } from './workos';");
+	}
+	return {
+		path: "src/index.ts",
+		content: lines.join("\n"),
+		skipIfExists: true
+	};
+}
+/**
+* Generate a worker-compatible barrel file that re-exports everything from
+* the main barrel. This keeps type exports in sync automatically.
+*/
+function generateWorkerBarrel(_spec, _ctx) {
+	const lines = [];
+	lines.push("export * from './index';");
+	return {
+		path: "src/index.worker.ts",
+		content: lines.join("\n"),
+		skipIfExists: true
+	};
+}
+function findEnumService(enumName, services) {
+	for (const service of services) for (const op of service.operations) {
+		const refs = [];
+		const collect = (ref) => {
+			if (ref?.kind === "enum" && ref.name === enumName) refs.push(ref.name);
+			if (ref?.items) collect(ref.items);
+			if (ref?.inner) collect(ref.inner);
+			if (ref?.variants) ref.variants.forEach(collect);
+			if (ref?.valueType) collect(ref.valueType);
+		};
+		if (op.requestBody) collect(op.requestBody);
+		collect(op.response);
+		for (const p of [...op.pathParams, ...op.queryParams]) collect(p.type);
+		if (refs.length > 0) return service.name;
+	}
+}
+/**
+* Determine whether the spec's auth scheme requires overriding the
+* default bearer auth in WorkOSBase.setAuthHeaders().
+*/
+function needsAuthOverride(auth) {
+	if (!auth || auth.length === 0) return false;
+	return auth[0].kind === "apiKey";
+}
+/**
+* Render the body of a setAuthHeaders override for non-default auth schemes.
+* Only called when needsAuthOverride() returns true.
+*/
+function renderAuthOverride(lines, auth) {
+	const scheme = auth[0];
+	if (scheme.kind !== "apiKey") return;
+	switch (scheme.in) {
+		case "header":
+			lines.push(`    headers['${scheme.name}'] = this.key;`);
+			break;
+		case "query":
+			lines.push(`    // Auth key sent as query parameter '${scheme.name}' (see buildUrl)`);
+			break;
+		case "cookie":
+			lines.push(`    headers['Cookie'] = \`${scheme.name}=\${this.key}\`;`);
+			break;
+	}
+}
+/**
+* Convert a server description or URL into a SCREAMING_SNAKE_CASE constant name.
+*/
+function serverConstName(description) {
+	return "SERVER_" + description.replace(/https?:\/\//g, "").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "").toUpperCase();
+}
+function generatePackageJson(ctx) {
+	const pkg = {
+		name: `@${ctx.namespace}/sdk`,
+		version: "0.0.0",
+		type: "module",
+		main: "src/index.ts",
+		types: "src/index.ts",
+		exports: { ".": "./src/index.ts" },
+		scripts: {
+			test: "jest",
+			build: "tsc"
+		},
+		devDependencies: {
+			typescript: "^5.0.0",
+			jest: "^29.0.0",
+			"jest-fetch-mock": "^3.0.0",
+			"@types/jest": "^29.0.0",
+			"ts-jest": "^29.0.0"
+		}
+	};
+	return {
+		path: "package.json",
+		content: JSON.stringify(pkg, null, 2),
+		skipIfExists: true,
+		integrateTarget: false
+	};
+}
+function generateTsConfig() {
+	return {
+		path: "tsconfig.json",
+		content: JSON.stringify({
+			compilerOptions: {
+				target: "ES2020",
+				module: "CommonJS",
+				lib: ["ES2020"],
+				declaration: true,
+				strict: true,
+				exactOptionalPropertyTypes: true,
+				esModuleInterop: true,
+				skipLibCheck: true,
+				forceConsistentCasingInFileNames: true,
+				resolveJsonModule: true,
+				outDir: "./lib",
+				rootDir: "./src"
+			},
+			include: ["src/**/*"],
+			exclude: [
+				"node_modules",
+				"lib",
+				"**/*.spec.ts"
+			]
+		}, null, 2),
+		skipIfExists: true,
+		integrateTarget: false
+	};
+}
+//#endregion
+//#region src/node/errors.ts
+function generateErrors(ctx) {
+	const files = [
+		{
+			path: "src/common/exceptions/bad-request.exception.ts",
+			content: `export class BadRequestException extends Error {
+  readonly status = 400;
+  readonly name = 'BadRequestException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    message,
+    requestID,
+  }: {
+    code?: string;
+    message?: string;
+    requestID: string;
+  }) {
+    super();
+    this.message = message ?? 'Bad request';
+    this.requestID = requestID;
+    if (code) this.code = code;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/unauthorized.exception.ts",
+			content: `export class UnauthorizedException extends Error {
+  readonly status = 401;
+  readonly name = 'UnauthorizedException';
+  readonly requestID: string;
+
+  constructor(requestID: string) {
+    super();
+    this.message = 'Unauthorized';
+    this.requestID = requestID;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/not-found.exception.ts",
+			content: `export class NotFoundException extends Error {
+  readonly status = 404;
+  readonly name = 'NotFoundException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    message,
+    path,
+    requestID,
+  }: {
+    code?: string;
+    message?: string;
+    path: string;
+    requestID: string;
+  }) {
+    super();
+    this.message =
+      message ?? \`The requested path '\${path}' could not be found.\`;
+    this.requestID = requestID;
+    if (code) this.code = code;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/conflict.exception.ts",
+			content: `export class ConflictException extends Error {
+  readonly status = 409;
+  readonly name = 'ConflictException';
+  readonly requestID: string;
+
+  constructor({
+    message,
+    requestID,
+  }: {
+    message?: string;
+    error?: string;
+    requestID: string;
+  }) {
+    super();
+    this.message = message ?? 'Conflict';
+    this.requestID = requestID;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/unprocessable-entity.exception.ts",
+			content: `export interface UnprocessableEntityError {
+  code: string;
+}
+
+export class UnprocessableEntityException extends Error {
+  readonly status = 422;
+  readonly name = 'UnprocessableEntityException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    errors,
+    message,
+    requestID,
+  }: {
+    code?: string;
+    errors?: UnprocessableEntityError[];
+    message?: string;
+    requestID: string;
+  }) {
+    super();
+    this.requestID = requestID;
+    this.message = message ?? 'Unprocessable entity';
+    if (code) this.code = code;
+    if (errors) {
+      const requirement =
+        errors.length === 1 ? 'requirement' : 'requirements';
+      this.message = \`The following \${requirement} must be met:\\n\`;
+      for (const { code: errCode } of errors) {
+        this.message = this.message.concat(\`\\t\${errCode}\\n\`);
+      }
+    }
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/rate-limit-exceeded.exception.ts",
+			content: `export class RateLimitExceededException extends Error {
+  readonly status = 429;
+  readonly name = 'RateLimitExceededException';
+  readonly requestID: string;
+  readonly retryAfter?: number;
+
+  constructor(message: string, requestID: string, retryAfter?: number) {
+    super();
+    this.message = message ?? 'Too many requests';
+    this.requestID = requestID;
+    this.retryAfter = retryAfter;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/generic-server.exception.ts",
+			content: `export class GenericServerException extends Error {
+  readonly status: number;
+  readonly name = 'GenericServerException';
+  readonly requestID: string;
+
+  constructor(status: number, message: string, requestID: string) {
+    super();
+    this.status = status;
+    this.message = message ?? 'Server error';
+    this.requestID = requestID;
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/no-api-key-provided.exception.ts",
+			content: `export class NoApiKeyProvidedException extends Error {
+  readonly name = 'NoApiKeyProvidedException';
+
+  constructor() {
+    super();
+    this.message =
+      'No API key provided. Pass it to the WorkOS constructor or set the WORKOS_API_KEY environment variable.';
+  }
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/exceptions/index.ts",
+			content: `export { BadRequestException } from './bad-request.exception';
+export { UnauthorizedException } from './unauthorized.exception';
+export { NotFoundException } from './not-found.exception';
+export { ConflictException } from './conflict.exception';
+export {
+  UnprocessableEntityException,
+  type UnprocessableEntityError,
+} from './unprocessable-entity.exception';
+export { RateLimitExceededException } from './rate-limit-exceeded.exception';
+export { GenericServerException } from './generic-server.exception';
+export { NoApiKeyProvidedException } from './no-api-key-provided.exception';`,
+			skipIfExists: true,
+			integrateTarget: false
+		}
+	];
+	if (ctx?.spec) {
+		const typedErrors = collectTypedErrors(ctx);
+		for (const { modelName, statusCode, baseException } of typedErrors) {
+			const exceptionClassName = `${modelName}Exception`;
+			const filePath = `src/common/exceptions/${fileName(modelName)}.exception.ts`;
+			const baseImport = baseException ? `import { ${baseException} } from './${fileName(baseException.replace(/Exception$/, "")).replace(/^/, "")}.exception';\n\n` : "";
+			const baseClass = baseException ?? "Error";
+			files.push({
+				path: filePath,
+				content: `${baseImport}export class ${exceptionClassName} extends ${baseClass} {
+  readonly status = ${statusCode};
+  readonly name = '${exceptionClassName}';
+  readonly requestID: string;
+  readonly data?: any;
+
+  constructor({ message, requestID, data }: { message?: string; requestID: string; data?: any }) {
+    ${baseException ? `super(${baseException === "UnauthorizedException" ? "requestID" : `{ message: message ?? '${modelName} error', requestID }`});` : "super();"}
+    this.message = message ?? '${modelName} error';
+    this.requestID = requestID;
+    if (data) this.data = data;
+  }
+}`,
+				skipIfExists: true,
+				integrateTarget: false
+			});
+			const existingIndex = files.find((f) => f.path === "src/common/exceptions/index.ts");
+			if (existingIndex) existingIndex.content += `\nexport { ${exceptionClassName} } from './${fileName(modelName)}.exception';`;
+		}
+	}
+	return files;
+}
+const STATUS_TO_BASE_EXCEPTION = {
+	400: "BadRequestException",
+	401: "UnauthorizedException",
+	404: "NotFoundException",
+	409: "ConflictException",
+	422: "UnprocessableEntityException",
+	429: "RateLimitExceededException"
+};
+function collectTypedErrors(ctx) {
+	const seen = /* @__PURE__ */ new Set();
+	const results = [];
+	for (const service of ctx.spec.services) for (const op of service.operations) for (const err of op.errors) if (err.type?.kind === "model" && !seen.has(err.type.name)) {
+		seen.add(err.type.name);
+		results.push({
+			modelName: err.type.name,
+			statusCode: err.statusCode,
+			baseException: STATUS_TO_BASE_EXCEPTION[err.statusCode] ?? (err.statusCode >= 500 ? "GenericServerException" : null)
+		});
+	}
+	return results;
+}
+//#endregion
+//#region src/node/config.ts
+function generateConfig() {
+	return [
+		{
+			path: "src/common/interfaces/workos-options.interface.ts",
+			content: `export interface WorkOSOptions {
+  apiKey?: string;
+  apiHostname?: string;
+  https?: boolean;
+  port?: number;
+  config?: RequestInit;
+  fetchFn?: typeof fetch;
+  clientId?: string;
+  timeout?: number;
+}
+
+export interface AppInfo {
+  name: string;
+  version?: string;
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/interfaces/post-options.interface.ts",
+			content: `export interface PostOptions {
+  query?: Record<string, any>;
+  idempotencyKey?: string;
+  warrantToken?: string;
+  skipApiKeyCheck?: boolean;
+  encoding?: 'json' | 'form-data' | 'form-urlencoded' | 'binary' | 'text';
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/interfaces/get-options.interface.ts",
+			content: `export interface GetOptions {
+  query?: Record<string, any>;
+  accessToken?: string;
+  warrantToken?: string;
+  skipApiKeyCheck?: boolean;
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/interfaces/pagination-options.interface.ts",
+			content: `export interface PaginationOptions {
+  limit?: number;
+  before?: string | null;
+  after?: string | null;
+  order?: 'asc' | 'desc';
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/interfaces/request-exception.interface.ts",
+			content: `export interface RequestException {
+  readonly status: number;
+  readonly name: string;
+  readonly requestID: string;
+  readonly code?: string;
+}`,
+			skipIfExists: true,
+			integrateTarget: false
+		}
+	];
+}
+//#endregion
+//#region src/node/common.ts
+function generateCommon() {
+	return [
+		{
+			path: "src/common/utils/pagination.ts",
+			content: paginationContent(),
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/utils/fetch-and-deserialize.ts",
+			content: fetchAndDeserializeContent(),
+			skipIfExists: true,
+			integrateTarget: true
+		},
+		{
+			path: "src/common/serializers/list.serializer.ts",
+			content: listSerializerContent(),
+			skipIfExists: true,
+			integrateTarget: false
+		},
+		{
+			path: "src/common/utils/test-utils.ts",
+			content: testUtilsContent(),
+			skipIfExists: true,
+			integrateTarget: true
+		}
+	];
+}
+function paginationContent() {
+	return `import type { PaginationOptions } from '../interfaces/pagination-options.interface';
+
+export interface ListMetadata {
+  before: string | null;
+  after: string | null;
+}
+
+export interface List<T> {
+  object: 'list';
+  data: T[];
+  listMetadata: ListMetadata;
+}
+
+export interface ListResponse<T> {
+  object: 'list';
+  data: T[];
+  list_metadata: {
+    before: string | null;
+    after: string | null;
+  };
+}
+
+export class AutoPaginatable<
+  ResourceType,
+  ParametersType extends PaginationOptions = PaginationOptions,
+> {
+  readonly object = 'list' as const;
+  readonly options: ParametersType;
+
+  constructor(
+    protected list: List<ResourceType>,
+    private apiCall: (params: PaginationOptions) => Promise<List<ResourceType>>,
+    options?: ParametersType,
+  ) {
+    this.options = options ?? ({} as ParametersType);
+  }
+
+  get data(): ResourceType[] {
+    return this.list.data;
+  }
+
+  get listMetadata() {
+    return this.list.listMetadata;
+  }
+
+  private async *generatePages(
+    params: PaginationOptions,
+  ): AsyncGenerator<ResourceType[]> {
+    const result = await this.apiCall({
+      ...this.options,
+      limit: 100,
+      after: params.after,
+    });
+    yield result.data;
+    if (result.listMetadata.after) {
+      await new Promise((resolve) => setTimeout(resolve, 350));
+      yield* this.generatePages({ after: result.listMetadata.after });
+    }
+  }
+
+  async autoPagination(): Promise<ResourceType[]> {
+    if (this.options.limit) {
+      return this.data;
+    }
+    const results: ResourceType[] = [];
+    for await (const page of this.generatePages({
+      after: this.options.after,
+    })) {
+      results.push(...page);
+    }
+    return results;
+  }
+}`;
+}
+function fetchAndDeserializeContent() {
+	return `import type { WorkOS } from '../../workos';
+import type { PaginationOptions } from '../interfaces/pagination-options.interface';
+import { AutoPaginatable, type List, type ListResponse } from './pagination';
+
+function setDefaultOptions(
+  options?: PaginationOptions,
+): Record<string, any> {
+  return {
+    order: 'desc',
+    ...options,
+  };
+}
+
+function deserializeList<T, U>(
+  data: ListResponse<T>,
+  deserializeFn: (item: T) => U,
+): List<U> {
+  return {
+    data: data.data.map(deserializeFn),
+    listMetadata: {
+      before: data.list_metadata.before,
+      after: data.list_metadata.after,
+    },
+  };
+}
+
+export const fetchAndDeserialize = async <T, U>(
+  workos: WorkOS,
+  endpoint: string,
+  deserializeFn: (data: T) => U,
+  options?: PaginationOptions,
+): Promise<List<U>> => {
+  const { data } = await workos.get<ListResponse<T>>(endpoint, {
+    query: setDefaultOptions(options),
+  });
+  return deserializeList(data, deserializeFn);
+};
+
+export async function createPaginatedList<TResponse, TModel, TOptions extends PaginationOptions>(
+  workos: WorkOS,
+  endpoint: string,
+  deserializeFn: (r: TResponse) => TModel,
+  options?: TOptions,
+): Promise<AutoPaginatable<TModel, TOptions>> {
+  return new AutoPaginatable(
+    await fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, options),
+    (params) => fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, params),
+    options,
+  );
+}`;
+}
+function listSerializerContent() {
+	return `import type { ListMetadata, ListResponse } from '../utils/pagination';
+
+export function deserializeListMetadata(
+  metadata: ListResponse<any>['list_metadata'],
+): ListMetadata {
+  return {
+    before: metadata.before,
+    after: metadata.after,
+  };
+}`;
+}
+function testUtilsContent() {
+	return `import fetch from 'jest-fetch-mock';
+
+interface MockParams {
+  status?: number;
+  headers?: Record<string, string>;
+  [key: string]: any;
+}
+
+export function fetchOnce(
+  response: any = {},
+  { status = 200, headers, ...rest }: MockParams = {},
+) {
+  return fetch.once(JSON.stringify(response), {
+    status,
+    headers: {
+      'content-type': 'application/json;charset=UTF-8',
+      ...headers,
+    },
+    ...rest,
+  });
+}
+
+export function fetchURL(): string {
+  return String(fetch.mock.calls[0][0]);
+}
+
+export function fetchMethod(): string {
+  return String(fetch.mock.calls[0][1]?.method ?? 'GET');
+}
+
+export function fetchSearchParams(): Record<string, string> {
+  return Object.fromEntries(new URL(fetchURL()).searchParams);
+}
+
+export function fetchHeaders(): Record<string, string> {
+  const headers = fetch.mock.calls[0][1]?.headers ?? {};
+  return headers as Record<string, string>;
+}
+
+export function fetchBody({ raw = false } = {}): any {
+  const body = fetch.mock.calls[0][1]?.body;
+  if (body instanceof URLSearchParams) return body.toString();
+  if (raw) return body;
+  return JSON.parse(String(body));
+}
+
+/**
+ * Shared test helper: asserts that the given async function throws when the
+ * server responds with 401 Unauthorized.
+ */
+export function testUnauthorized(fn: () => Promise<any>) {
+  it('throws on unauthorized', async () => {
+    fetchOnce({ message: 'Unauthorized' }, { status: 401 });
+    await expect(fn()).rejects.toThrow('Unauthorized');
+  });
+}
+
+/**
+ * Shared test helper: asserts that a paginated list call returns the expected
+ * shape (data array + listMetadata) and hits the correct endpoint.
+ */
+export function testPaginatedList(
+  fn: () => Promise<any>,
+  pathContains: string,
+) {
+  it('returns paginated results', async () => {
+    // Caller must have called fetchOnce with the list fixture before invoking fn
+    const { data, listMetadata } = await fn();
+    expect(fetchURL()).toContain(pathContains);
+    expect(fetchSearchParams()).toHaveProperty('order');
+    expect(Array.isArray(data)).toBe(true);
+    expect(listMetadata).toBeDefined();
+  });
+}
+
+/**
+ * Shared test helper: asserts that a paginated list call returns empty data
+ * when the server responds with an empty list.
+ */
+export function testEmptyResults(fn: () => Promise<any>) {
+  it('handles empty results', async () => {
+    fetchOnce({ data: [], list_metadata: { before: null, after: null } });
+    const { data } = await fn();
+    expect(data).toEqual([]);
+  });
+}
+
+/**
+ * Shared test helper: asserts that pagination params are forwarded correctly.
+ */
+export function testPaginationParams(fn: (opts: any) => Promise<any>, fixture: any) {
+  it('forwards pagination params', async () => {
+    fetchOnce(fixture);
+    await fn({ limit: 10, after: 'cursor_abc' });
+    expect(fetchSearchParams()['limit']).toBe('10');
+    expect(fetchSearchParams()['after']).toBe('cursor_abc');
+  });
+}`;
+}
+//#endregion
+//#region src/node/tests.ts
+function generateTests(spec, ctx) {
+	const files = [];
+	const fixtures = generateFixtures(spec, ctx);
+	for (const f of fixtures) files.push({
+		path: f.path,
+		content: f.content,
+		headerPlacement: "skip"
+	});
+	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+	for (const service of spec.services) {
+		if (isServiceCoveredByExisting(service, ctx)) continue;
+		const ops = uncoveredOperations(service, ctx);
+		if (ops.length === 0) continue;
+		const testService = ops.length < service.operations.length ? {
+			...service,
+			operations: ops
+		} : service;
+		files.push(generateServiceTest(testService, spec, ctx, modelMap));
+	}
+	const serializerTests = generateSerializerTests(spec, ctx);
+	for (const f of serializerTests) files.push(f);
+	return files;
+}
+function generateServiceTest(service, spec, ctx, modelMap) {
+	const resolvedName = resolveResourceClassName(service, ctx);
+	const serviceDir = serviceDirName(resolvedName);
+	const serviceClass = resolvedName;
+	const serviceProp = servicePropertyName(resolvedName);
+	const testPath = `src/${serviceDir}/${fileName(resolvedName)}.spec.ts`;
+	const plans = service.operations.map((op) => ({
+		op,
+		plan: planOperation(op),
+		method: resolveMethodName(op, service, ctx)
+	}));
+	if (ctx.overlayLookup?.methodByOperation) {
+		const methodOrder = /* @__PURE__ */ new Map();
+		let pos = 0;
+		for (const [, info] of ctx.overlayLookup.methodByOperation) if (!methodOrder.has(info.methodName)) methodOrder.set(info.methodName, pos++);
+		if (methodOrder.size > 0) plans.sort((a, b) => {
+			return (methodOrder.get(a.method) ?? Number.MAX_SAFE_INTEGER) - (methodOrder.get(b.method) ?? Number.MAX_SAFE_INTEGER);
+		});
+	}
+	const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+	const lines = [];
+	lines.push("import fetch from 'jest-fetch-mock';");
+	const hasPaginated = plans.some((p) => p.plan.isPaginated);
+	const hasBody = plans.some((p) => p.plan.hasBody);
+	const testUtils = [
+		"fetchOnce",
+		"fetchURL",
+		"fetchMethod"
+	];
+	if (hasPaginated) testUtils.push("fetchSearchParams");
+	if (hasBody) testUtils.push("fetchBody");
+	if (hasPaginated) testUtils.push("testEmptyResults", "testPaginationParams");
+	if (plans.some((p) => p.plan.responseModelName || p.plan.isPaginated)) testUtils.push("testUnauthorized");
+	lines.push("import {");
+	for (const util of testUtils) lines.push(`  ${util},`);
+	lines.push("} from '../common/utils/test-utils';");
+	lines.push("import { WorkOS } from '../workos';");
+	lines.push("");
+	const fixtureImports = /* @__PURE__ */ new Set();
+	for (const { op, plan } of plans) if (plan.isPaginated && op.pagination) {
+		let itemModelName = op.pagination.itemType.kind === "model" ? op.pagination.itemType.name : null;
+		if (itemModelName) {
+			const rawModel = modelMap.get(itemModelName);
+			if (rawModel) {
+				const unwrapped = unwrapListModel(rawModel, modelMap);
+				if (unwrapped) itemModelName = unwrapped.name;
+			}
+			const fixturePath = `./fixtures/list-${fileName(itemModelName)}.fixture.json`;
+			fixtureImports.add(`import list${itemModelName}Fixture from '${fixturePath}';`);
+		}
+	} else if (plan.responseModelName) {
+		const respDir = resolveDir(modelToService.get(plan.responseModelName));
+		const fixturePath = respDir === serviceDir ? `./fixtures/${fileName(plan.responseModelName)}.fixture.json` : `../${respDir}/fixtures/${fileName(plan.responseModelName)}.fixture.json`;
+		fixtureImports.add(`import ${toCamelCase(plan.responseModelName)}Fixture from '${fixturePath}';`);
+	}
+	for (const imp of fixtureImports) lines.push(imp);
+	lines.push("");
+	lines.push("const workos = new WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');");
+	lines.push("");
+	const { lines: helperLines, helpers: entityHelperNames } = generateEntityHelpers(plans, modelMap, ctx);
+	for (const line of helperLines) lines.push(line);
+	lines.push(`describe('${serviceClass}', () => {`);
+	lines.push("  beforeEach(() => fetch.resetMocks());");
+	for (const { op, plan, method } of plans) {
+		lines.push("");
+		lines.push(`  describe('${method}', () => {`);
+		if (plan.isPaginated) renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelperNames);
+		else if (plan.isDelete) renderDeleteTest(lines, op, plan, method, serviceProp, modelMap);
+		else if (plan.hasBody && plan.responseModelName) renderBodyTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelperNames);
+		else if (plan.responseModelName) renderGetTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelperNames);
+		else renderVoidTest(lines, op, plan, method, serviceProp, modelMap);
+		if (plan.responseModelName || plan.isPaginated) renderErrorTest(lines, op, plan, method, serviceProp, modelMap);
+		lines.push("  });");
+	}
+	lines.push("});");
+	return {
+		path: testPath,
+		content: lines.join("\n"),
+		skipIfExists: true
+	};
+}
+/** Compute the test value for a single path parameter.
+*  Uses distinct values per param name so multi-param paths don't all get 'test_id'.
+*/
+function pathParamTestValue(param, paramName) {
+	if (param?.type.kind === "enum" && param.type.values?.length) {
+		const first = param.type.values[0];
+		return typeof first === "string" ? first : String(first);
+	}
+	const name = paramName ?? param?.name;
+	if (name) return `test_${fieldName(name)}`;
+	return "test_id";
+}
+/** Build test arguments for all path params (handles multiple path params). */
+function buildTestPathArgs(op) {
+	const templateVars = [...op.path.matchAll(/\{(\w+)\}/g)].map(([, name]) => fieldName(name));
+	const declaredNames = new Set(op.pathParams.map((p) => fieldName(p.name)));
+	const paramByName = new Map(op.pathParams.map((p) => [fieldName(p.name), p]));
+	const allVars = [];
+	for (const p of op.pathParams) allVars.push(fieldName(p.name));
+	for (const v of templateVars) if (!declaredNames.has(v)) allVars.push(v);
+	return allVars.map((varName) => `'${pathParamTestValue(paramByName.get(varName), varName)}'`).join(", ");
+}
+function renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelpers) {
+	let itemModelName = op.pagination?.itemType.kind === "model" ? op.pagination.itemType.name : "Item";
+	const rawModel = itemModelName !== "Item" ? modelMap.get(itemModelName) : null;
+	if (rawModel) {
+		const unwrapped = unwrapListModel(rawModel, modelMap);
+		if (unwrapped) itemModelName = unwrapped.name;
+	}
+	const pathArgs = buildTestPathArgs(op);
+	lines.push("    it('returns paginated results', async () => {");
+	lines.push(`      fetchOnce(list${itemModelName}Fixture);`);
+	lines.push("");
+	lines.push(`      const { data, listMetadata } = await workos.${serviceProp}.${method}(${pathArgs});`);
+	lines.push("");
+	lines.push("      expect(fetchMethod()).toBe('GET');");
+	const expectedPath = buildExpectedPath(op);
+	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPath}');`);
+	lines.push("      expect(fetchSearchParams()).toHaveProperty('order');");
+	lines.push("      expect(Array.isArray(data)).toBe(true);");
+	lines.push("      expect(listMetadata).toBeDefined();");
+	const paginatedHelperName = ctx ? `expect${resolveInterfaceName(itemModelName, ctx)}` : null;
+	if (paginatedHelperName && entityHelpers?.has(paginatedHelperName)) {
+		lines.push("      expect(data.length).toBeGreaterThan(0);");
+		lines.push(`      ${paginatedHelperName}(data[0]);`);
+	} else {
+		const itemModel = modelMap.get(itemModelName);
+		if (itemModel) {
+			const assertions = buildFieldAssertions(itemModel, "data[0]", modelMap);
+			if (assertions.length > 0) {
+				lines.push("      expect(data.length).toBeGreaterThan(0);");
+				for (const assertion of assertions) lines.push(`      ${assertion}`);
+			}
+		}
+	}
+	lines.push("    });");
+	lines.push("");
+	lines.push(`    testEmptyResults(() => workos.${serviceProp}.${method}(${pathArgs}));`);
+	lines.push("");
+	lines.push(`    testPaginationParams(`);
+	lines.push(`      (opts) => workos.${serviceProp}.${method}(${pathArgs ? pathArgs + ", " : ""}opts),`);
+	lines.push(`      list${itemModelName}Fixture,`);
+	lines.push("    );");
+}
+function renderDeleteTest(lines, op, plan, method, serviceProp, modelMap) {
+	const pathArgs = buildTestPathArgs(op);
+	const payload = plan.hasBody ? buildTestPayload(op, modelMap) : null;
+	const bodyArg = plan.hasBody ? payload ? payload.camelCaseObj : fallbackBodyArg(op, modelMap) : "";
+	const args = plan.hasBody ? pathArgs ? `${pathArgs}, ${bodyArg}` : bodyArg : pathArgs;
+	lines.push("    it('sends a DELETE request', async () => {");
+	lines.push("      fetchOnce({}, { status: 204 });");
+	lines.push("");
+	lines.push(`      await workos.${serviceProp}.${method}(${args});`);
+	lines.push("");
+	lines.push("      expect(fetchMethod()).toBe('DELETE');");
+	const expectedPathDel = buildExpectedPath(op);
+	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPathDel}');`);
+	if (plan.hasBody) if (payload) lines.push(`      expect(fetchBody()).toEqual(expect.objectContaining(${payload.snakeCaseObj}));`);
+	else lines.push("      expect(fetchBody()).toBeDefined();");
+	lines.push("    });");
+}
+function renderBodyTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelpers) {
+	const responseModelName = plan.responseModelName;
+	const fixture = `${toCamelCase(responseModelName)}Fixture`;
+	const pathArgs = buildTestPathArgs(op);
+	const payload = buildTestPayload(op, modelMap);
+	const payloadArg = payload ? payload.camelCaseObj : fallbackBodyArg(op, modelMap);
+	const allArgs = pathArgs ? `${pathArgs}, ${payloadArg}` : payloadArg;
+	lines.push("    it('sends the correct request and returns result', async () => {");
+	lines.push(`      fetchOnce(${fixture});`);
+	lines.push("");
+	lines.push(`      const result = await workos.${serviceProp}.${method}(${allArgs});`);
+	lines.push("");
+	lines.push(`      expect(fetchMethod()).toBe('${op.httpMethod.toUpperCase()}');`);
+	const expectedPath = buildExpectedPath(op);
+	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPath}');`);
+	if (payload) lines.push(`      expect(fetchBody()).toEqual(expect.objectContaining(${payload.snakeCaseObj}));`);
+	else lines.push("      expect(fetchBody()).toBeDefined();");
+	const bodyHelperName = ctx ? `expect${resolveInterfaceName(responseModelName, ctx)}` : null;
+	if (bodyHelperName && entityHelpers?.has(bodyHelperName)) lines.push(`      ${bodyHelperName}(result);`);
+	else {
+		const responseModel = modelMap.get(responseModelName);
+		if (responseModel) {
+			const assertions = buildFieldAssertions(responseModel, "result", modelMap);
+			if (assertions.length > 0) for (const assertion of assertions) lines.push(`      ${assertion}`);
+			else lines.push("      expect(result).toBeDefined();");
+		} else lines.push("      expect(result).toBeDefined();");
+	}
+	lines.push("    });");
+}
+function renderGetTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelpers) {
+	const responseModelName = plan.responseModelName;
+	const fixture = `${toCamelCase(responseModelName)}Fixture`;
+	const pathArgs = buildTestPathArgs(op);
+	lines.push("    it('returns the expected result', async () => {");
+	lines.push(`      fetchOnce(${fixture});`);
+	lines.push("");
+	lines.push(`      const result = await workos.${serviceProp}.${method}(${pathArgs});`);
+	lines.push("");
+	lines.push(`      expect(fetchMethod()).toBe('${op.httpMethod.toUpperCase()}');`);
+	const expectedPathGet = buildExpectedPath(op);
+	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPathGet}');`);
+	const helperName = ctx ? `expect${resolveInterfaceName(responseModelName, ctx)}` : null;
+	if (helperName && entityHelpers?.has(helperName)) lines.push(`      ${helperName}(result);`);
+	else {
+		const responseModel = modelMap.get(responseModelName);
+		if (responseModel) {
+			const assertions = buildFieldAssertions(responseModel, "result", modelMap);
+			if (assertions.length > 0) for (const assertion of assertions) lines.push(`      ${assertion}`);
+			else lines.push("      expect(result).toBeDefined();");
+		} else lines.push("      expect(result).toBeDefined();");
+	}
+	lines.push("    });");
+}
+function renderVoidTest(lines, op, plan, method, serviceProp, modelMap) {
+	const pathArgs = buildTestPathArgs(op);
+	const payload = plan.hasBody ? buildTestPayload(op, modelMap) : null;
+	const bodyArg = plan.hasBody ? payload ? payload.camelCaseObj : fallbackBodyArg(op, modelMap) : "";
+	const args = plan.hasBody ? pathArgs ? `${pathArgs}, ${bodyArg}` : bodyArg : pathArgs;
+	lines.push("    it('sends the request', async () => {");
+	lines.push("      fetchOnce({});");
+	lines.push("");
+	lines.push(`      await workos.${serviceProp}.${method}(${args});`);
+	lines.push("");
+	lines.push(`      expect(fetchMethod()).toBe('${op.httpMethod.toUpperCase()}');`);
+	const expectedPathVoid = buildExpectedPath(op);
+	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPathVoid}');`);
+	if (plan.hasBody && payload) lines.push(`      expect(fetchBody()).toEqual(expect.objectContaining(${payload.snakeCaseObj}));`);
+	lines.push("    });");
+}
+function renderErrorTest(lines, op, plan, method, serviceProp, modelMap) {
+	const args = buildCallArgs(op, plan, modelMap);
+	lines.push("");
+	lines.push(`    testUnauthorized(() => workos.${serviceProp}.${method}(${args}));`);
+	const errorStatuses = new Set(op.errors.map((e) => e.statusCode));
+	if (errorStatuses.has(404) && (method.startsWith("get") || method.startsWith("find"))) {
+		lines.push("");
+		lines.push("    it('throws NotFoundException on 404', async () => {");
+		lines.push("      fetchOnce('', { status: 404 });");
+		lines.push(`      await expect(workos.${serviceProp}.${method}(${args})).rejects.toThrow();`);
+		lines.push("    });");
+	}
+	if (errorStatuses.has(422) && (method.startsWith("create") || method.startsWith("update"))) {
+		lines.push("");
+		lines.push("    it('throws UnprocessableEntityException on 422', async () => {");
+		lines.push("      fetchOnce('', { status: 422 });");
+		lines.push(`      await expect(workos.${serviceProp}.${method}(${args})).rejects.toThrow();`);
+		lines.push("    });");
+	}
+}
+/**
+* Build the argument string for a method call in tests.
+* Shared by renderErrorTest and other test renderers.
+*/
+function buildCallArgs(op, plan, modelMap) {
+	const pathArgs = buildTestPathArgs(op);
+	const isPaginated = plan.isPaginated;
+	const hasBody = plan.hasBody;
+	if (isPaginated) return pathArgs || "";
+	if (hasBody) {
+		const fb = fallbackBodyArg(op, modelMap);
+		return pathArgs ? `${pathArgs}, ${fb}` : fb;
+	}
+	return pathArgs || "";
+}
+/**
+* Generate per-entity assertion helper functions for models used in 2+ tests.
+* Returns lines like: function expectConnection(result: any) { expect(...) }
+*/
+/**
+* Generate per-entity assertion helper functions for models used in 2+ tests.
+* Returns { lines, helpers } where helpers is a Set of helper function names.
+*/
+function generateEntityHelpers(plans, modelMap, ctx) {
+	const modelUsage = /* @__PURE__ */ new Map();
+	for (const { op, plan } of plans) {
+		let modelName = null;
+		if (plan.isPaginated && op.pagination?.itemType.kind === "model") {
+			modelName = op.pagination.itemType.name;
+			const rawModel = modelMap.get(modelName);
+			if (rawModel) {
+				const unwrapped = unwrapListModel(rawModel, modelMap);
+				if (unwrapped) modelName = unwrapped.name;
+			}
+		} else if (plan.responseModelName) modelName = plan.responseModelName;
+		if (modelName) modelUsage.set(modelName, (modelUsage.get(modelName) ?? 0) + 1);
+	}
+	const lines = [];
+	const helpers = /* @__PURE__ */ new Set();
+	for (const [modelName, count] of modelUsage) {
+		if (count < 2) continue;
+		const model = modelMap.get(modelName);
+		if (!model) continue;
+		const assertions = buildFieldAssertions(model, "result", modelMap);
+		if (assertions.length === 0) continue;
+		const helperName = `expect${resolveInterfaceName(modelName, ctx)}`;
+		if (helpers.has(helperName)) continue;
+		helpers.add(helperName);
+		lines.push(`function ${helperName}(result: any) {`);
+		for (const assertion of assertions) lines.push(`  ${assertion}`);
+		lines.push("}");
+		lines.push("");
+	}
+	return {
+		lines,
+		helpers
+	};
+}
+/**
+* Build field-level assertions for top-level primitive fields of a response model.
+* Returns lines like: expect(result.fieldName).toBe(fixtureValue);
+*
+* When the top level has no assertable primitive fields (e.g. wrapper types
+* whose only required fields are nested models), recurse one level into those
+* nested models so we still get meaningful assertions instead of a bare
+* `toBeDefined()`.
+*/
+function buildFieldAssertions(model, accessor, modelMap) {
+	const assertions = [];
+	for (const field of model.fields) {
+		if (!field.required) continue;
+		if (field.example !== void 0) {
+			const domainField = fieldName(field.name);
+			if (typeof field.example === "object" && field.example !== null) assertions.push(`expect(${accessor}.${domainField}).toEqual(${JSON.stringify(field.example)});`);
+			else {
+				const exampleLiteral = typeof field.example === "string" ? `'${field.example}'` : String(field.example);
+				assertions.push(`expect(${accessor}.${domainField}).toBe(${exampleLiteral});`);
+			}
+			continue;
+		}
+		const value = fixtureValueForType(field.type, field.name, model.name);
+		if (value === null) continue;
+		const domainField = fieldName(field.name);
+		assertions.push(`expect(${accessor}.${domainField}).toBe(${value});`);
+	}
+	if (assertions.length === 0 && modelMap) for (const field of model.fields) {
+		if (!field.required) continue;
+		if (field.type.kind === "model") {
+			const nestedModel = modelMap.get(field.type.name);
+			if (nestedModel) {
+				const nested = buildFieldAssertions(nestedModel, `${accessor}.${fieldName(field.name)}`);
+				assertions.push(...nested);
+			}
+		}
+	}
+	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.).
+*/
+function fixtureValueForType(ref, name, modelName) {
+	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);
+		case "enum":
+			if (ref.values?.length) {
+				const first = ref.values[0];
+				return typeof first === "string" ? `'${first}'` : String(first);
+			}
+			return null;
+		case "array": {
+			const itemValue = fixtureValueForType(ref.items, name, modelName);
+			if (itemValue !== null) return `[${itemValue}]`;
+			return null;
+		}
+		default: return null;
+	}
+}
+function fixtureValueForPrimitive(type, format, name, modelName) {
+	switch (type) {
+		case "string":
+			if (format === "date-time") return "'2023-01-01T00:00:00.000Z'";
+			if (format === "date") return "'2023-01-01'";
+			if (format === "uuid") return "'00000000-0000-0000-0000-000000000000'";
+			if (name === "id") return `'${ID_PREFIXES[modelName] ?? ""}01234'`;
+			if (name.includes("id")) return `'${wireFieldName(name)}_01234'`;
+			if (name.includes("email")) return "'test@example.com'";
+			if (name.includes("url") || name.includes("uri")) return "'https://example.com'";
+			if (name.includes("name")) return "'Test'";
+			return `'test_${wireFieldName(name)}'`;
+		case "integer": return "1";
+		case "number": return "1";
+		case "boolean": return "true";
+		default: return null;
+	}
+}
+/**
+* Build the expected full URL path for an operation, substituting path params
+* with their test values. Returns a string like '/organizations/test_id'.
+*/
+function buildExpectedPath(op) {
+	let path = op.path;
+	for (const param of op.pathParams) path = path.replace(`{${param.name}}`, pathParamTestValue(param, fieldName(param.name)));
+	return path;
+}
+/**
+* Build a realistic test payload for a request body model.
+* Returns { camelCaseObj, snakeCaseObj } as inline JS object literal strings,
+* or null if the request body is not a named model.
+*
+* camelCaseObj is what the SDK consumer passes (e.g. { organizationName: 'Test' })
+* snakeCaseObj is the expected wire format (e.g. { organization_name: 'Test' })
+*/
+function buildTestPayload(op, modelMap) {
+	if (!op.requestBody || op.requestBody.kind !== "model") return null;
+	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);
+	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 camelKey = fieldName(field.name);
+		const snakeKey = wireFieldName(field.name);
+		camelEntries.push(`${camelKey}: ${value}`);
+		snakeEntries.push(`${snakeKey}: ${value}`);
+	}
+	return {
+		camelCaseObj: `{ ${camelEntries.join(", ")} }`,
+		snakeCaseObj: `{ ${snakeEntries.join(", ")} }`
+	};
+}
+/**
+* Compute a fallback body argument when buildTestPayload returns null.
+* If the request body model has no required fields (all optional), an empty
+* object `{}` is a valid value and doesn't need a type assertion. Otherwise,
+* fall back to `{} as any` to bypass type checking for complex required fields.
+*/
+function fallbackBodyArg(op, modelMap) {
+	if (!op.requestBody || op.requestBody.kind !== "model") return "{} as any";
+	const model = modelMap.get(op.requestBody.name);
+	if (!model) return "{} as any";
+	return model.fields.some((f) => f.required) ? "{} as any" : "{}";
+}
+/**
+* Determine whether a model should get a round-trip serializer test.
+* Includes all models with at least one field — every model gets both
+* serialize and deserialize functions, so all benefit from round-trip testing.
+*/
+function modelNeedsRoundTripTest(model) {
+	return model.fields.length > 0;
+}
+/**
+* Generate serializer round-trip tests for models that have both serialize and
+* deserialize functions and have nested types requiring non-trivial serialization.
+*/
+function generateSerializerTests(spec, ctx) {
+	const files = [];
+	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 eligibleModels = spec.models.filter((m) => modelNeedsRoundTripTest(m) && !isListMetadataModel(m) && !isListWrapperModel(m));
+	if (eligibleModels.length === 0) return files;
+	const modelsByDir = /* @__PURE__ */ new Map();
+	for (const model of eligibleModels) {
+		const dirName = resolveDir(modelToService.get(model.name));
+		if (!modelsByDir.has(dirName)) modelsByDir.set(dirName, []);
+		modelsByDir.get(dirName).push(model);
+	}
+	for (const [dirName, models] of modelsByDir) {
+		const testPath = `src/${dirName}/serializers.spec.ts`;
+		const lines = [];
+		const serializerImports = [];
+		const fixtureImports = [];
+		for (const model of models) {
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const modelDir = resolveDir(modelToService.get(model.name));
+			const serializerPath = `src/${modelDir}/serializers/${fileName(model.name)}.serializer.ts`;
+			const fixturePath = `src/${modelDir}/fixtures/${fileName(model.name)}.fixture.json`;
+			serializerImports.push(`import { deserialize${domainName}, serialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`);
+			fixtureImports.push(`import ${toCamelCase(model.name)}Fixture from '${relativeImport(testPath, fixturePath)}';`);
+		}
+		for (const imp of serializerImports) lines.push(imp);
+		for (const imp of fixtureImports) lines.push(imp);
+		lines.push("");
+		for (const model of models) {
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const fixtureName = `${toCamelCase(model.name)}Fixture`;
+			lines.push(`describe('${domainName}Serializer', () => {`);
+			lines.push("  it('round-trips through serialize/deserialize', () => {");
+			lines.push(`    const fixture = ${fixtureName};`);
+			lines.push(`    const deserialized = deserialize${domainName}(fixture);`);
+			lines.push(`    const reserialized = serialize${domainName}(deserialized);`);
+			lines.push("    expect(reserialized).toEqual(expect.objectContaining(fixture));");
+			lines.push("  });");
+			lines.push("});");
+			lines.push("");
+		}
+		files.push({
+			path: testPath,
+			content: lines.join("\n"),
+			skipIfExists: true,
+			integrateTarget: false
+		});
+	}
+	return files;
+}
+//#endregion
+//#region src/node/manifest.ts
+function generateManifest(spec, ctx) {
+	const manifest = {};
+	for (const service of spec.services) {
+		const propName = servicePropertyName(resolveResourceClassName(service, ctx));
+		for (const op of service.operations) {
+			const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+			manifest[httpKey] = {
+				sdkMethod: resolveMethodName(op, service, ctx),
+				service: propName
+			};
+		}
+	}
+	return [{
+		path: "smoke-manifest.json",
+		content: JSON.stringify(manifest, null, 2),
+		integrateTarget: false,
+		overwriteExisting: true
+	}];
+}
+//#endregion
+//#region src/node/index.ts
+const nodeEmitter = {
+	language: "node",
+	generateModels(models, ctx) {
+		return [...generateModels(models, ctx), ...generateSerializers(models, ctx)];
+	},
+	generateEnums(enums, ctx) {
+		return generateEnums(enums, ctx);
+	},
+	generateResources(services, ctx) {
+		return generateResources(services, ctx);
+	},
+	generateClient(spec, ctx) {
+		return generateClient(spec, ctx);
+	},
+	generateErrors(ctx) {
+		return generateErrors(ctx);
+	},
+	generateConfig(_ctx) {
+		return [...generateConfig(), ...generateCommon()];
+	},
+	generateTypeSignatures(_spec, _ctx) {
+		return [];
+	},
+	generateTests(spec, ctx) {
+		return generateTests(spec, ctx);
+	},
+	generateManifest(spec, ctx) {
+		return generateManifest(spec, ctx);
+	},
+	fileHeader() {
+		return "// This file is auto-generated by oagen. Do not edit.";
+	}
+};
+//#endregion
+export { nodeEmitter };
+
+//# sourceMappingURL=index.mjs.map