@workos/oagen-emitters 0.14.4 → 0.15.0

package/dist/{plugin-BGVaMGqe.mjs → plugin-CO4RFgAW.mjs}

@@ -2855,6 +2855,15 @@ function isAdoptedModelName(name) {
 	return adoptedModelNames.has(name);
 }
 /**
+* IR model names handled by the discriminated-models module. These must not
+* be remapped by the structural matcher because that module emits files and
+* helpers under the original IR names.
+*/
+let discriminatedModelNames = /* @__PURE__ */ new Set();
+function setDiscriminatedModelNames(names) {
+	discriminatedModelNames = names;
+}
+/**
 * Domain names that `resolveInterfaceName` reached via a structural rename
 * — the resolved name differs from the IR model's own name. `wireInterfaceName`
 * consults this set to decide whether to fire the "single-form wire" case:
@@ -2980,7 +2989,7 @@ function resolveClassName$5(service, ctx) {
 function resolveInterfaceName(name, ctx, opts) {
 	const existing = ctx.overlayLookup?.interfaceByName?.get(name);
 	if (existing) return existing;
-	let inferred = adoptedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
+	let inferred = adoptedModelNames.has(name) || discriminatedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
 	if (inferred) {
 		if (inferred.startsWith("Serialized")) {
 			const stripped = inferred.slice(10);
@@ -3825,6 +3834,25 @@ function assignEnumsToServices(enums, services, models = [], ctx) {
 	return enumToService;
 }
 //#endregion
+//#region src/node/options.ts
+function nodeOptions(ctx) {
+	return ctx.emitterOptions ?? {};
+}
+function normalizeServiceName(name) {
+	return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+function ownedLookupNames(name) {
+	const names = [name];
+	if (name.startsWith("__baseline_dir__:")) names.push(name.slice(17));
+	return names;
+}
+function isNodeOwnedService(ctx, ...names) {
+	const configured = nodeOptions(ctx).ownedServices ?? [];
+	if (configured.length === 0) return false;
+	const owned = new Set(configured.map(normalizeServiceName));
+	return names.some((name) => name !== void 0 ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false);
+}
+//#endregion
 //#region src/node/field-plan.ts
 /**
 * Decide whether a `deserialize${X}` / `serialize${X}` helper will be
@@ -3843,6 +3871,15 @@ function helperExists(helperName, depModelName, ctx) {
 	if (liveSurfaceHasFunction(helperName)) return true;
 	const depModel = ctx.spec.models.find((m) => m.name === depModelName);
 	if (!depModel) return false;
+	const depService = assignModelsToServices$1(ctx.spec.models, ctx.spec.services, ctx.modelHints).get(depModelName);
+	const resolvedName = resolveInterfaceName(depModelName, ctx);
+	const siblingPath = liveSurfaceFunctionPath(`${helperName.startsWith("serialize") ? "deserialize" : "serialize"}${resolvedName}`);
+	if (siblingPath && liveSurfaceHasFile(siblingPath) && !liveSurfaceHasAutogenFile(siblingPath)) return false;
+	const sourceFile = (ctx.apiSurface?.interfaces?.[resolvedName])?.sourceFile;
+	const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
+	const candidate = sourceFile ? sourceFile.replace("/interfaces/", "/serializers/").replace(".interface.ts", ".serializer.ts") : `src/${resolveDir(depService)}/serializers/${fileName$3(depModelName)}.serializer.ts`;
+	if (liveSurfaceHasFile(candidate) && !liveSurfaceHasAutogenFile(candidate)) return false;
+	if (isNodeOwnedService(ctx, depService)) return true;
 	return modelHasNewFields(depModel, ctx);
 }
 function deserializeExpression$1(ref, wireExpr, ctx, nullFallback = "null") {
@@ -4201,11 +4238,12 @@ function buildSerializerImports(model, serializerPath, dirName, domainName, resp
 		const depService = sctx.modelToService.get(dep);
 		const depDir = sctx.resolveDir(depService);
 		const depName = resolveInterfaceName(dep, sctx.ctx);
-		const baselineSrc = (sctx.ctx.apiSurface?.interfaces?.[depName])?.sourceFile;
+		const depIsOwned = isNodeOwnedService(sctx.ctx, depService);
+		const baselineSrc = depIsOwned ? void 0 : (sctx.ctx.apiSurface?.interfaces?.[depName])?.sourceFile;
 		const baselineSerializerPath = baselineSrc ? baselineSrc.replace("/interfaces/", "/serializers/").replace(".interface.ts", ".serializer.ts") : null;
 		const irNameSerializerPath = `src/${depDir}/serializers/${fileName$3(dep)}.serializer.ts`;
-		const liveDeserPath = liveSurfaceFunctionPath(`deserialize${depName}`);
-		const liveSerPath = liveSurfaceFunctionPath(`serialize${depName}`);
+		const liveDeserPath = depIsOwned ? void 0 : liveSurfaceFunctionPath(`deserialize${depName}`);
+		const liveSerPath = depIsOwned ? void 0 : liveSurfaceFunctionPath(`serialize${depName}`);
 		const depSerializerPath = liveDeserPath ?? liveSerPath ?? (baselineSerializerPath && liveSurfaceHasFile(baselineSerializerPath) ? baselineSerializerPath : irNameSerializerPath);
 		const rel = relativeImport(serializerPath, depSerializerPath);
 		const canon = sctx.dedup.get(dep);
@@ -4213,11 +4251,11 @@ function buildSerializerImports(model, serializerPath, dirName, domainName, resp
 		const depSkipDeserialize = sctx.responseReachableModels !== void 0 && !sctx.responseReachableModels.has(dep) && (canon == null || !sctx.responseReachableModels.has(canon));
 		const hasDeser = liveSurfaceHasFunction(`deserialize${depName}`);
 		const hasSer = liveSurfaceHasFunction(`serialize${depName}`);
-		const fileExists = liveSurfaceHasFile(depSerializerPath);
+		const fileExists = !depIsOwned && liveSurfaceHasFile(depSerializerPath);
 		if (fileExists && !hasDeser && !hasSer) continue;
 		if (!fileExists) {
 			const depModel = sctx.ctx.spec.models.find((m) => m.name === dep);
-			if (!(depModel ? modelHasNewFields(depModel, sctx.ctx) : true)) continue;
+			if (!(depModel ? depIsOwned || modelHasNewFields(depModel, sctx.ctx) : true)) continue;
 		}
 		if (fileExists && depSkipSerialize) {
 			if (hasDeser) lines.push(`import { deserialize${depName} } from '${rel}';`);
@@ -4252,7 +4290,7 @@ function buildSkipFormatFields(model, baselineDomain) {
 	return skipFormatFields;
 }
 function shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, dedup, skippedSerializeModels, ctx) {
-	let shouldSkip = serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx);
+	let shouldSkip = serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx) || hasUnsafeSerializePassthrough(model, baselineDomain, baselineResponse, ctx);
 	if (!shouldSkip) for (const field of model.fields) {
 		for (const ref of collectSerializedModelRefs(field.type)) {
 			if (skippedSerializeModels.has(ref)) {
@@ -4264,6 +4302,11 @@ function shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, de
 				shouldSkip = true;
 				break;
 			}
+			const resolved = resolveInterfaceName(ref, ctx);
+			if (wireInterfaceName(resolved) !== resolved && !helperExists(`serialize${resolved}`, ref, ctx)) {
+				shouldSkip = true;
+				break;
+			}
 		}
 		if (shouldSkip) break;
 	}
@@ -4271,6 +4314,7 @@ function shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, de
 }
 function emitSerializerBody(model, domainName, responseName, typeParams, baselineDomain, baselineResponse, skipFormatFields, shouldSkipSerialize, shouldSkipDeserialize, ctx) {
 	const lines = [];
+	const effectiveShouldSkipSerialize = shouldSkipSerialize || hasUnsafeSerializePassthrough(model, baselineDomain, baselineResponse, ctx);
 	if (!shouldSkipDeserialize) {
 		const seenDeserFields = /* @__PURE__ */ new Set();
 		const deserParamPrefix = model.fields.length === 0 ? "_" : "";
@@ -4286,7 +4330,7 @@ function emitSerializerBody(model, domainName, responseName, typeParams, baselin
 		}
 		lines.push("});");
 	}
-	if (!shouldSkipSerialize) {
+	if (!effectiveShouldSkipSerialize) {
 		if (!shouldSkipDeserialize) lines.push("");
 		const serParamPrefix = model.fields.length === 0 ? "_" : "";
 		lines.push(`export const serialize${domainName} = ${typeParams.decl}(`);
@@ -4304,19 +4348,18 @@ function emitSerializerBody(model, domainName, responseName, typeParams, baselin
 	}
 	return lines;
 }
-//#endregion
-//#region src/node/options.ts
-function nodeOptions(ctx) {
-	return ctx.emitterOptions ?? {};
-}
-function normalizeServiceName(name) {
-	return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
-}
-function isNodeOwnedService(ctx, ...names) {
-	const configured = nodeOptions(ctx).ownedServices ?? [];
-	if (configured.length === 0) return false;
-	const owned = new Set(configured.map(normalizeServiceName));
-	return names.some((name) => name !== void 0 && owned.has(normalizeServiceName(name)));
+function hasUnsafeSerializePassthrough(model, baselineDomain, baselineResponse, ctx) {
+	if (!baselineDomain?.fields || !baselineResponse?.fields) return false;
+	for (const field of model.fields) {
+		const domain = fieldName$6(field.name);
+		const wire = wireFieldName(field.name);
+		const domainField = baselineDomain.fields[domain];
+		const wireField = baselineResponse.fields[wire];
+		if (!domainField || !wireField || domainField.type === wireField.type) continue;
+		const domainAccess = `model.${domain}`;
+		if (serializeExpression(field.type, domainAccess, ctx) === domainAccess) return true;
+	}
+	return false;
 }
 //#endregion
 //#region src/node/sdk-errors.ts
@@ -4634,10 +4677,52 @@ function paginatedOptionsName(method, resolvedServiceName) {
 	if (method === "list") return `${toPascalCase(resolvedServiceName)}ListOptions`;
 	return toPascalCase(method) + "Options";
 }
+function recordGeneratedOptionInterface(ctx, serviceDir, stem, typeName) {
+	const key = "_nodeGeneratedOptionInterfaceExports";
+	const registry = ctx[key] ??= /* @__PURE__ */ new Map();
+	const exports = registry.get(serviceDir) ?? [];
+	if (!exports.some((entry) => entry.stem === stem && entry.typeName === typeName)) exports.push({
+		stem,
+		typeName
+	});
+	registry.set(serviceDir, exports);
+}
+function existingInterfaceBarrelExports(ctx, serviceDir, stem) {
+	const root = ctx.outputDir ?? ctx.targetDir;
+	if (!root) return false;
+	const barrelPath = path.join(root, "src", serviceDir, "interfaces", "index.ts");
+	let content;
+	try {
+		content = fs.readFileSync(barrelPath, "utf8");
+	} catch {
+		return false;
+	}
+	const escapedStem = stem.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`export\\s+(?:type\\s+)?(?:\\*|\\{[^}]+\\})\\s+from\\s+['"]\\./${escapedStem}['"]`).test(content);
+}
+function operationOverrideFor$1(ctx, op) {
+	return nodeOptions(ctx).operationOverrides?.[`${op.httpMethod.toUpperCase()} ${op.path}`];
+}
 function baselineMethodFor$1(service, method, ctx) {
 	const serviceClass = resolveResourceClassName$3(service, ctx);
 	return ctx.apiSurface?.classes?.[serviceClass]?.methods?.[method]?.[0];
 }
+function ignoredResourceMethodNames(ctx, resourcePath) {
+	const root = ctx.outputDir ?? ctx.targetDir;
+	if (!root) return /* @__PURE__ */ new Set();
+	let content;
+	try {
+		content = fs.readFileSync(path.join(root, resourcePath), "utf8");
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+	const methods = /* @__PURE__ */ new Set();
+	for (const block of content.matchAll(/@oagen-ignore-start[\s\S]*?@oagen-ignore-end/g)) for (const line of block[0].split("\n")) {
+		const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/);
+		if (match) methods.add(match[1]);
+	}
+	return methods;
+}
 function optionsObjectParam$1(method) {
 	if (!method || method.params.length !== 1) return void 0;
 	const [param] = method.params;
@@ -4645,10 +4730,56 @@ function optionsObjectParam$1(method) {
 	if (param.passingStyle && param.passingStyle !== "options_object") return void 0;
 	if (!param.type || /^(Record|object|any|unknown)\b/.test(param.type)) return void 0;
 	return {
-		name: param.name,
-		type: param.type
+		name: "options",
+		type: param.type,
+		optional: param.optional === true,
+		generated: false
 	};
 }
+function methodOptionsName$1(method, resolvedServiceName) {
+	if (method === "list") return `${toPascalCase(resolvedServiceName)}ListOptions`;
+	return `${toPascalCase(method)}Options`;
+}
+function hiddenParamsFor(resolvedOp) {
+	return new Set([...Object.keys(getOpDefaults(resolvedOp)), ...getOpInferFromClient(resolvedOp)]);
+}
+function visibleQueryParamsForOptions(op, plan, resolvedOp) {
+	const hidden = hiddenParamsFor(resolvedOp);
+	return op.queryParams.filter((param) => {
+		if (hidden.has(param.name)) return false;
+		if (plan.isPaginated && PAGINATION_PARAM_NAMES.has(param.name)) return false;
+		return true;
+	});
+}
+function optionsObjectShouldBeOptional(op, plan, resolvedOp) {
+	if (plan.hasBody) return false;
+	if (op.pathParams.length > 0) return false;
+	return visibleQueryParamsForOptions(op, plan, resolvedOp).every((param) => !param.required);
+}
+function operationHasOptionsInput(op, plan, resolvedOp) {
+	return op.pathParams.length > 0 || plan.hasBody || plan.isPaginated || visibleQueryParamsForOptions(op, plan, resolvedOp).length > 0;
+}
+function optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, resolvedOp) {
+	const baseline = optionsObjectParam$1(baselineMethod);
+	if (baseline) return baseline;
+	const overrideType = operationOverrideFor$1(ctx, op)?.optionsType;
+	if (overrideType) return {
+		name: "options",
+		type: overrideType,
+		optional: optionsObjectShouldBeOptional(op, plan, resolvedOp),
+		generated: baselineTypeSourceFile(ctx, overrideType) === void 0
+	};
+	if (!operationHasOptionsInput(op, plan, resolvedOp)) return void 0;
+	return {
+		name: "options",
+		type: methodOptionsName$1(method, resolveResourceClassName$3(service, ctx)),
+		optional: optionsObjectShouldBeOptional(op, plan, resolvedOp),
+		generated: true
+	};
+}
+function renderOptionsParam(param) {
+	return `options${param.optional ? "?" : ""}: ${param.type}`;
+}
 function autoPaginatableItemType$1(returnType) {
 	return returnType?.match(/\bAutoPaginatable<\s*([A-Za-z_$][\w$]*)/)?.[1];
 }
@@ -4738,43 +4869,83 @@ function deduplicateMethodNames(plans, _ctx) {
 	}
 }
 /**
-* Emit one interface file per paginated list operation that has extension
-* query params.  Placing the options interface under `interfaces/` lets the
-* per-service barrel pick it up via `export * from './interfaces'`, which
-* is what the root `src/index.ts` re-exports.  When the interface was
-* declared inline in the resource file, it was unreachable from the barrel
-* and callers couldn't import the type by name from the package root.
+* Emit one interface/type file per generated options-object operation.
+* Placing the options type under `interfaces/` lets the per-service barrel
+* pick it up via `export * from './interfaces'`.
 */
-function generatePaginatedOptionsInterfaces(service, ctx, specEnumNames) {
+function generateOptionsInterfaces(service, ctx, specEnumNames) {
 	const files = [];
-	const resolvedName = resolveResourceClassName$3(service, ctx);
 	const serviceDir = resolveResourceDir(service, ctx);
+	const resolvedLookup = buildResolvedLookup(ctx);
 	const plans = service.operations.map((op) => ({
 		op,
 		plan: planOperation(op),
 		method: resolveMethodName$6(op, service, ctx)
 	}));
 	for (const { op, plan, method } of plans) {
-		if (!plan.isPaginated) continue;
-		const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
-		if (extraParams.length === 0) continue;
-		const optionsName = paginatedOptionsName(method, resolvedName);
-		const filePath = `src/${serviceDir}/interfaces/${fileName$3(optionsName)}.interface.ts`;
+		const resolvedOp = lookupResolved(op, resolvedLookup);
+		const optionInfo = optionsObjectInfo(service, method, op, plan, ctx, baselineMethodFor$1(service, method, ctx), resolvedOp);
+		if (!optionInfo?.generated) continue;
+		if (baselineTypeSourceFile(ctx, optionInfo.type)) continue;
+		const optionsName = optionInfo.type;
+		const optionFileStem = `${fileName$3(optionsName)}.interface`;
+		const filePath = `src/${serviceDir}/interfaces/${optionFileStem}.ts`;
+		if (!liveSurfaceHasFile(filePath) || existingInterfaceBarrelExports(ctx, serviceDir, optionFileStem)) recordGeneratedOptionInterface(ctx, serviceDir, optionFileStem, optionsName);
+		const optEnums = /* @__PURE__ */ new Set();
+		const optModels = /* @__PURE__ */ new Set();
+		for (const param of [...op.pathParams, ...visibleQueryParamsForOptions(op, plan, resolvedOp)]) collectParamTypeRefs(param.type, optEnums, optModels);
+		const bodyInfo = extractRequestBodyType(op, ctx);
+		if (bodyInfo?.kind === "model") {
+			const bodyModel = ctx.spec.models.find((m) => m.name === bodyInfo.name);
+			if (bodyModel) for (const field of bodyModel.fields) collectParamTypeRefs(field.type, optEnums, optModels);
+		} else if (bodyInfo?.kind === "union") for (const name of bodyInfo.modelNames) optModels.add(name);
 		const lines = [];
-		lines.push("import type { PaginationOptions } from '../../common/interfaces/pagination-options.interface';");
+		if (plan.isPaginated) lines.push("import type { PaginationOptions } from '../../common/interfaces/pagination-options.interface';");
+		const { modelToService, resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
+		if (optEnums.size > 0) {
+			const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services, ctx.spec.models, ctx);
+			for (const name of optEnums) {
+				if (!specEnumNames.has(name)) continue;
+				if (isInlineEnum(name)) continue;
+				const enumDir = resolveDir(enumToService.get(name));
+				const relPath = enumDir === serviceDir ? `./${fileName$3(name)}.interface` : `../../${enumDir}/interfaces/${fileName$3(name)}.interface`;
+				lines.push(`import type { ${name} } from '${relPath}';`);
+			}
+		}
+		for (const name of optModels) {
+			const modelDir = resolveDir(modelToService.get(name));
+			const relPath = modelDir === serviceDir ? `./${fileName$3(name)}.interface` : `../../${modelDir}/interfaces/${fileName$3(name)}.interface`;
+			lines.push(`import type { ${resolveInterfaceName(name, ctx)} } from '${relPath}';`);
+		}
 		lines.push("");
-		lines.push(`export interface ${optionsName} extends PaginationOptions {`);
-		for (const param of extraParams) {
-			const opt = !param.required ? "?" : "";
-			if (param.description || param.deprecated) {
+		const headerParts = [];
+		const pushField = (name, required, type, description, deprecated) => {
+			const opt = !required ? "?" : "";
+			if (description || deprecated) {
 				const parts = [];
-				if (param.description) parts.push(param.description);
-				if (param.deprecated) parts.push("@deprecated");
-				lines.push(...docComment$2(parts.join("\n"), 2));
+				if (description) parts.push(description);
+				if (deprecated) parts.push("@deprecated");
+				headerParts.push(...docComment$2(parts.join("\n"), 2));
 			}
-			lines.push(`  ${fieldName$6(param.name)}${opt}: ${mapParamType(param.type, specEnumNames)};`);
+			headerParts.push(`  ${name}${opt}: ${type};`);
+		};
+		for (const param of op.pathParams) pushField(fieldName$6(param.name), true, mapParamType(param.type, specEnumNames), param.description, param.deprecated);
+		for (const param of visibleQueryParamsForOptions(op, plan, resolvedOp)) pushField(fieldName$6(param.name), param.required, mapParamType(param.type, specEnumNames), param.description, param.deprecated);
+		if (bodyInfo?.kind === "model") {
+			const bodyModel = ctx.spec.models.find((m) => m.name === bodyInfo.name);
+			if (bodyModel) for (const field of bodyModel.fields) pushField(fieldName$6(field.name), field.required, mapParamType(field.type, specEnumNames), field.description, field.deprecated);
+			lines.push(`export interface ${optionsName}${plan.isPaginated ? " extends PaginationOptions" : ""} {`);
+			lines.push(...headerParts);
+			lines.push("}");
+		} else if (bodyInfo?.kind === "union") {
+			const baseType = headerParts.length > 0 ? `{\n${headerParts.join("\n")}\n}` : "{}";
+			lines.push(`export type ${optionsName} = ${baseType} & (${bodyInfo.typeStr});`);
+		} else if (plan.isPaginated && headerParts.length === 0) lines.push(`export type ${optionsName} = PaginationOptions;`);
+		else {
+			lines.push(`export interface ${optionsName}${plan.isPaginated ? " extends PaginationOptions" : ""} {`);
+			lines.push(...headerParts);
+			lines.push("}");
 		}
-		lines.push("}");
 		files.push({
 			path: filePath,
 			content: lines.join("\n")
@@ -4819,7 +4990,7 @@ function generateResources$7(services, ctx) {
 	}
 	for (const service of mergedServices) {
 		if (!isNodeOwnedService(ctx, service.name, resolveResourceClassName$3(service, ctx)) && isServiceCoveredByExisting(service, ctx) && !hasMethodsAbsentFromBaseline(service, ctx)) continue;
-		files.push(...generatePaginatedOptionsInterfaces(service, ctx, topLevelEnumNames));
+		files.push(...generateOptionsInterfaces(service, ctx, topLevelEnumNames));
 	}
 	return files;
 }
@@ -4844,27 +5015,40 @@ function generateResourceClass(service, ctx) {
 			return (httpKeyOrder.get(aKey) ?? Number.MAX_SAFE_INTEGER) - (httpKeyOrder.get(bKey) ?? Number.MAX_SAFE_INTEGER);
 		});
 	}
+	const ignoredMethodNames = ignoredResourceMethodNames(ctx, resourcePath);
 	const baselineMethodNames = new Set(Object.keys(ctx.apiSurface?.classes?.[serviceClass]?.methods ?? {}));
 	const planCountBeforeFilter = plans.length;
+	if (ignoredMethodNames.size > 0) plans = plans.filter((p) => !ignoredMethodNames.has(p.method));
 	if (!isNodeOwnedService(ctx, service.name, serviceClass) && baselineMethodNames.size > 0) plans = plans.filter((p) => !baselineMethodNames.has(p.method));
 	const filteredOut = planCountBeforeFilter - plans.length;
 	if (plans.length === 0 && filteredOut > 0) return null;
 	const hasPaginated = plans.some((p) => p.plan.isPaginated);
-	const needsPaginationOptionsImport = plans.some((p) => p.plan.isPaginated && (!optionsObjectParam$1(baselineMethodFor$1(service, p.method, ctx)) || /\bPaginationOptions\b/.test(preferredBaselineReturnType(ctx, baselineMethodFor$1(service, p.method, ctx)?.returnType) ?? "")));
+	const resolvedLookup = buildResolvedLookup(ctx);
+	const needsPaginationOptionsImport = plans.some((p) => {
+		const baseline = baselineMethodFor$1(service, p.method, ctx);
+		const optionInfo = optionsObjectInfo(service, p.method, p.op, p.plan, ctx, baseline, lookupResolved(p.op, resolvedLookup));
+		const needsWireSerializer = p.op.queryParams.filter((param) => !PAGINATION_PARAM_NAMES.has(param.name)).some((param) => fieldName$6(param.name) !== wireFieldName(param.name));
+		return p.plan.isPaginated && (needsWireSerializer || !optionInfo || /\bPaginationOptions\b/.test(preferredBaselineReturnType(ctx, baselineMethodFor$1(service, p.method, ctx)?.returnType) ?? ""));
+	});
 	const modelMap = new Map(ctx.spec.models.map((m) => [m.name, m]));
 	const responseModels = /* @__PURE__ */ new Set();
+	const responseModelsForSignature = /* @__PURE__ */ new Set();
 	const requestModels = /* @__PURE__ */ new Set();
 	const requestModelsForSignature = /* @__PURE__ */ new Set();
 	const paramEnums = /* @__PURE__ */ new Set();
 	const paramModels = /* @__PURE__ */ new Set();
 	const optionObjectTypes = /* @__PURE__ */ new Set();
+	const returnTypeImports = /* @__PURE__ */ new Set();
 	const baselineResponseTypes = /* @__PURE__ */ new Set();
-	for (const { op, plan } of plans) {
-		const baselineMethod = baselineMethodFor$1(service, resolveMethodName$6(op, service, ctx), ctx);
-		const existingOptions = optionsObjectParam$1(baselineMethod);
+	for (const { op, plan, method } of plans) {
+		const baselineMethod = baselineMethodFor$1(service, method, ctx);
+		const existingOptions = optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, lookupResolved(op, resolvedLookup));
 		if (existingOptions) optionObjectTypes.add(existingOptions.type);
-		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);
+		for (const typeName of operationOverrideFor$1(ctx, op)?.returnTypeImports ?? []) returnTypeImports.add(typeName);
+		if (!existingOptions) {
+			const queryParams = plan.isPaginated ? [] : op.queryParams;
+			for (const param of [...queryParams, ...op.pathParams]) collectParamTypeRefs(param.type, paramEnums, paramModels);
+		}
 		const baselinePaginatedItemType = existingOptions ? preferredBaselineTypeName(ctx, autoPaginatableItemType$1(baselineMethod?.returnType)) : void 0;
 		if (plan.isPaginated && baselinePaginatedItemType) baselineResponseTypes.add(baselinePaginatedItemType);
 		else if (plan.isPaginated && op.pagination?.itemType.kind === "model") {
@@ -4875,7 +5059,13 @@ function generateResourceClass(service, ctx) {
 				if (unwrapped) itemName = unwrapped.name;
 			}
 			responseModels.add(itemName);
-		} else if (plan.responseModelName) responseModels.add(plan.responseModelName);
+			responseModelsForSignature.add(itemName);
+		} else if (plan.responseModelName) {
+			responseModels.add(plan.responseModelName);
+			const override = operationOverrideFor$1(ctx, op);
+			const resolvedResponseName = resolveInterfaceName(plan.responseModelName, ctx);
+			if (!override?.returnType || override.returnType.includes(resolvedResponseName)) responseModelsForSignature.add(plan.responseModelName);
+		}
 		const bodyInfo = extractRequestBodyType(op, ctx);
 		if (bodyInfo?.kind === "model") {
 			requestModels.add(bodyInfo.name);
@@ -4889,7 +5079,6 @@ function generateResourceClass(service, ctx) {
 			if (!existingOptions) requestModelsForSignature.add(name);
 		}
 	}
-	const resolvedLookup = buildResolvedLookup(ctx);
 	for (const { op } of plans) {
 		const resolved = lookupResolved(op, resolvedLookup);
 		if (resolved) {
@@ -4898,7 +5087,7 @@ function generateResourceClass(service, ctx) {
 		}
 	}
 	const allModels = new Set([
-		...responseModels,
+		...responseModelsForSignature,
 		...requestModelsForSignature,
 		...paramModels
 	]);
@@ -4909,12 +5098,8 @@ function generateResourceClass(service, ctx) {
 		lines.push("import { AutoPaginatable } from '../common/utils/pagination';");
 		lines.push("import { fetchAndDeserialize } from '../common/utils/fetch-and-deserialize';");
 	}
-	for (const { op, plan, method } of plans) {
-		if (!plan.isPaginated) continue;
-		if (op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name)).length === 0) continue;
-		const optionsName = paginatedOptionsName(method, resolvedName);
-		lines.push(`import type { ${optionsName} } from './interfaces/${fileName$3(optionsName)}.interface';`);
-	}
+	const shouldEmitVaultCryptoHelpers = serviceClass === "Vault" && !ignoredMethodNames.has("encrypt") && !ignoredMethodNames.has("decrypt");
+	if (shouldEmitVaultCryptoHelpers) lines.push("import { base64ToUint8Array, uint8ArrayToBase64 } from '../common/utils/base64';");
 	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';");
@@ -4922,7 +5107,16 @@ function generateResourceClass(service, ctx) {
 	for (const optionType of optionObjectTypes) {
 		if (importedTypeNames.has(optionType)) continue;
 		importedTypeNames.add(optionType);
-		lines.push(`import type { ${optionType} } from './interfaces/${fileName$3(optionType)}.interface';`);
+		const sourceFile = baselineTypeSourceFile(ctx, optionType);
+		const relPath = sourceFile ? relativeImport(resourcePath, sourceFile) : `./interfaces/${fileName$3(optionType)}.interface`;
+		lines.push(`import type { ${optionType} } from '${relPath}';`);
+	}
+	for (const typeName of returnTypeImports) {
+		if (importedTypeNames.has(typeName)) continue;
+		const sourceFile = baselineTypeSourceFile(ctx, typeName) ?? liveSurfaceInterfacePath(typeName);
+		if (!sourceFile) continue;
+		importedTypeNames.add(typeName);
+		lines.push(`import type { ${typeName} } from '${relativeImport(resourcePath, sourceFile)}';`);
 	}
 	const { modelToService, resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 	const usedWireTypes = /* @__PURE__ */ new Set();
@@ -4954,6 +5148,17 @@ function generateResourceClass(service, ctx) {
 		lines.push(`import type { ${wireName} } from '${relPath}';`);
 		importedTypeNames.add(wireName);
 	}
+	for (const name of responseModels) {
+		if (allModels.has(name)) continue;
+		const resolved = resolveInterfaceName(name, ctx);
+		if (!usedWireTypes.has(resolved)) continue;
+		const wireName = wireInterfaceName(resolved);
+		if (importedTypeNames.has(wireName)) continue;
+		const modelServiceDir = resolveDir(modelToService.get(name));
+		const relPath = modelServiceDir === serviceDir ? `./interfaces/${fileName$3(name)}.interface` : `../${modelServiceDir}/interfaces/${fileName$3(name)}.interface`;
+		lines.push(`import type { ${wireName} } from '${relPath}';`);
+		importedTypeNames.add(wireName);
+	}
 	for (const name of baselineResponseTypes) {
 		if (importedTypeNames.has(name)) continue;
 		const wireName = wireInterfaceName(name);
@@ -5017,47 +5222,60 @@ function generateResourceClass(service, ctx) {
 		}
 	}
 	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);
-			if (extraParams.some((p) => fieldName$6(p.name) !== wireFieldName(p.name))) {
-				const serializerName = `serialize${optionsName}`;
-				lines.push(`const ${serializerName} = (options: ${optionsName}): PaginationOptions => {`);
-				lines.push("  const wire: Record<string, unknown> = {");
-				for (const p of PAGINATION_PARAM_NAMES) lines.push(`    ${p}: options.${p},`);
-				lines.push("  };");
-				for (const param of extraParams) {
-					const camel = fieldName$6(param.name);
-					const snake = wireFieldName(param.name);
-					lines.push(`  if (options.${camel} !== undefined) wire.${snake} = options.${camel};`);
+	for (const { op, plan, method } of plans) {
+		const resolved = lookupResolved(op, resolvedLookup);
+		const optionInfo = optionsObjectInfo(service, method, op, plan, ctx, baselineMethodFor$1(service, method, ctx), resolved);
+		if (plan.isPaginated) {
+			const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
+			if (extraParams.length > 0) {
+				const optionsName = optionInfo?.type ?? paginatedOptionsName(method, resolvedName);
+				if (extraParams.some((p) => fieldName$6(p.name) !== wireFieldName(p.name))) {
+					const serializerName = `serialize${optionsName}`;
+					lines.push(`const ${serializerName} = (options: ${optionsName}): PaginationOptions => {`);
+					lines.push("  const wire: Record<string, unknown> = {");
+					for (const p of PAGINATION_PARAM_NAMES) lines.push(`    ${p}: options.${p},`);
+					lines.push("  };");
+					for (const param of extraParams) {
+						const camel = fieldName$6(param.name);
+						const snake = wireFieldName(param.name);
+						lines.push(`  if (options.${camel} !== undefined) wire.${snake} = options.${camel};`);
+					}
+					lines.push("  return wire as PaginationOptions;");
+					lines.push("};");
+					lines.push("");
 				}
-				lines.push("  return wire as PaginationOptions;");
-				lines.push("};");
-				lines.push("");
 			}
-		}
-	} else if (!plan.isPaginated && !plan.hasBody && !plan.isDelete && op.queryParams.length > 0) {
-		const resolved = lookupResolved(op, resolvedLookup);
-		const opHiddenParams = new Set([...Object.keys(getOpDefaults(resolved)), ...getOpInferFromClient(resolved)]);
-		const visibleParams = op.queryParams.filter((p) => !opHiddenParams.has(p.name));
-		if (visibleParams.length > 0) {
-			const optionsName = toPascalCase(method) + "Options";
-			lines.push(`export interface ${optionsName} {`);
-			for (const param of visibleParams) {
-				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$2(parts.join("\n"), 2));
+		} else if (!optionInfo && !plan.isPaginated && !plan.hasBody && !plan.isDelete && op.queryParams.length > 0) {
+			const resolved = lookupResolved(op, resolvedLookup);
+			const opHiddenParams = new Set([...Object.keys(getOpDefaults(resolved)), ...getOpInferFromClient(resolved)]);
+			const visibleParams = op.queryParams.filter((p) => !opHiddenParams.has(p.name));
+			if (visibleParams.length > 0) {
+				const optionsName = toPascalCase(method) + "Options";
+				lines.push(`export interface ${optionsName} {`);
+				for (const param of visibleParams) {
+					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$2(parts.join("\n"), 2));
+					}
+					lines.push(`  ${fieldName$6(param.name)}${opt}: ${mapParamType(param.type, specEnumNames)};`);
 				}
-				lines.push(`  ${fieldName$6(param.name)}${opt}: ${mapParamType(param.type, specEnumNames)};`);
+				lines.push("}");
+				lines.push("");
 			}
-			lines.push("}");
-			lines.push("");
 		}
 	}
+	if (shouldEmitVaultCryptoHelpers) {
+		lines.push("export interface VaultEncryptedData {");
+		lines.push("  ciphertext: string;");
+		lines.push("  encryptedKeys: string;");
+		lines.push("  iv: string;");
+		lines.push("  tag: string;");
+		lines.push("}");
+		lines.push("");
+	}
 	if (service.description) lines.push(...docComment$2(service.description));
 	lines.push(`export class ${serviceClass} {`);
 	lines.push("  constructor(private readonly workos: WorkOS) {}");
@@ -5067,6 +5285,10 @@ function generateResourceClass(service, ctx) {
 		lines.push(...renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames, resolved));
 		if (resolved?.wrappers && resolved.wrappers.length > 0) lines.push(...generateWrapperMethods$5(resolved, ctx));
 	}
+	if (shouldEmitVaultCryptoHelpers) {
+		lines.push("");
+		lines.push(...renderVaultCryptoMethods());
+	}
 	lines.push("}");
 	return {
 		path: resourcePath,
@@ -5074,6 +5296,51 @@ function generateResourceClass(service, ctx) {
 		skipIfExists: true
 	};
 }
+function renderVaultCryptoMethods() {
+	return [
+		"  async encrypt(",
+		"    plaintext: string,",
+		"    context: Record<string, string>,",
+		"    aad?: string,",
+		"  ): Promise<VaultEncryptedData> {",
+		"    const dataKeyPair = await this.createDataKey({ context });",
+		"    const encodedPlaintext = new TextEncoder().encode(plaintext);",
+		"    const encodedAad = aad ? new TextEncoder().encode(aad) : undefined;",
+		"    const encrypted = await this.workos.getCryptoProvider().encrypt(",
+		"      encodedPlaintext,",
+		"      base64ToUint8Array(dataKeyPair.dataKey.key),",
+		"      undefined,",
+		"      encodedAad,",
+		"    );",
+		"",
+		"    return {",
+		"      ciphertext: uint8ArrayToBase64(encrypted.ciphertext),",
+		"      encryptedKeys: dataKeyPair.encryptedKeys,",
+		"      iv: uint8ArrayToBase64(encrypted.iv),",
+		"      tag: uint8ArrayToBase64(encrypted.tag),",
+		"    };",
+		"  }",
+		"",
+		"  async decrypt(",
+		"    encryptedData: VaultEncryptedData,",
+		"    aad?: string,",
+		"  ): Promise<string> {",
+		"    const dataKey = await this.decryptDataKey({",
+		"      keys: encryptedData.encryptedKeys,",
+		"    });",
+		"    const encodedAad = aad ? new TextEncoder().encode(aad) : undefined;",
+		"    const decrypted = await this.workos.getCryptoProvider().decrypt(",
+		"      base64ToUint8Array(encryptedData.ciphertext),",
+		"      base64ToUint8Array(dataKey.key),",
+		"      base64ToUint8Array(encryptedData.iv),",
+		"      base64ToUint8Array(encryptedData.tag),",
+		"      encodedAad,",
+		"    );",
+		"",
+		"    return new TextDecoder().decode(decrypted);",
+		"  }"
+	];
+}
 function renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames, resolvedOp) {
 	const lines = [];
 	const responseModel = plan.responseModelName ? resolveInterfaceName(plan.responseModelName, ctx) : null;
@@ -5081,9 +5348,11 @@ function renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames,
 	const hiddenParams = new Set([...Object.keys(getOpDefaults(resolvedOp)), ...getOpInferFromClient(resolvedOp)]);
 	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
 	const baselineClassMethod = baselineMethodFor$1(service, method, ctx);
+	const optionInfo = optionsObjectInfo(service, method, op, plan, ctx, baselineClassMethod, resolvedOp);
 	const overlayMethod = ctx.overlayLookup?.methodByOperation?.get(httpKey) ?? baselineClassMethod;
 	let validParamNames = null;
-	if (overlayMethod) validParamNames = new Set(overlayMethod.params.map((p) => p.name));
+	if (optionInfo) validParamNames = new Set(["options"]);
+	else 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$6(p.name));
@@ -5219,7 +5488,7 @@ function renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames,
 			}
 		}
 	}
-	if (renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelMap, specEnumNames, baselineClassMethod)) return lines;
+	if (renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelMap, specEnumNames, baselineClassMethod, resolvedOp)) return lines;
 	const preDecisionCount = lines.length;
 	if (plan.isPaginated && op.pagination && op.httpMethod === "get") {
 		let paginatedItemRawName = op.pagination.itemType.kind === "model" ? op.pagination.itemType.name : null;
@@ -5246,12 +5515,17 @@ function renderMethod$2(op, plan, method, service, ctx, modelMap, specEnumNames,
 	}
 	return lines;
 }
-function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelMap, specEnumNames, baselineMethod) {
-	const optionParam = optionsObjectParam$1(baselineMethod);
+function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelMap, specEnumNames, baselineMethod, resolvedOp) {
+	const optionParam = optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, resolvedOp);
 	if (!optionParam) return false;
 	const responseModel = plan.responseModelName ? resolveInterfaceName(plan.responseModelName, ctx) : null;
 	const pathBindings = buildOptionsObjectPathBindings(op, optionParam.type, ctx);
 	const pathStr = buildPathStr(op, buildOptionsObjectPathParamMap(op, optionParam.type, ctx));
+	const override = operationOverrideFor$1(ctx, op);
+	const bodyFieldMap = override?.bodyFieldMap;
+	const visibleQueryParams = visibleQueryParamsForOptions(op, plan, resolvedOp);
+	const queryBindings = visibleQueryParams.map((param) => fieldName$6(param.name));
+	const queryOptionsArg = visibleQueryParams.length > 0 || Object.keys(getOpDefaults(resolvedOp)).length > 0 || getOpInferFromClient(resolvedOp).length > 0 ? `, { query: ${renderQueryExprWithOptions(visibleQueryParams, optionParam.optional, resolvedOp)} }` : "";
 	if (plan.isPaginated && op.pagination && op.httpMethod === "get") {
 		let itemRawName = op.pagination.itemType.kind === "model" ? op.pagination.itemType.name : null;
 		if (itemRawName) {
@@ -5265,14 +5539,15 @@ function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelM
 		if (!itemType) return false;
 		const wireType = wireInterfaceName(itemType);
 		const returnType = preferredBaselineReturnType(ctx, baselineMethod?.returnType) ?? `Promise<AutoPaginatable<${itemType}>>`;
-		lines.push(`  async ${method}(options: ${optionParam.type}): ${returnType} {`);
+		const listOptionsExpr = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name)).some((p) => fieldName$6(p.name) !== wireFieldName(p.name)) ? `options ? serialize${optionParam.type}(options) : undefined` : "paginationOptions";
+		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${returnType} {`);
 		renderOptionsObjectDestructure(lines, pathBindings, "paginationOptions");
 		lines.push(`    return new AutoPaginatable(`);
 		lines.push(`      await fetchAndDeserialize<${wireType}, ${itemType}>(`);
 		lines.push(`        this.workos,`);
 		lines.push(`        ${pathStr},`);
 		lines.push(`        deserialize${itemType},`);
-		lines.push(`        paginationOptions,`);
+		lines.push(`        ${listOptionsExpr},`);
 		lines.push(`      ),`);
 		lines.push(`      (params) =>`);
 		lines.push(`        fetchAndDeserialize<${wireType}, ${itemType}>(`);
@@ -5287,9 +5562,9 @@ function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelM
 		return true;
 	}
 	if (plan.isDelete && !plan.hasBody) {
-		lines.push(`  async ${method}(options: ${optionParam.type}): Promise<void> {`);
+		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): Promise<void> {`);
 		renderOptionsObjectDestructure(lines, pathBindings);
-		lines.push(`    await this.workos.delete(${pathStr});`);
+		lines.push(`    await this.workos.delete(${pathStr}${queryOptionsArg});`);
 		lines.push("  }");
 		return true;
 	}
@@ -5312,40 +5587,56 @@ function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelM
 			entityType = requestType;
 		}
 		if (plan.isDelete) {
-			lines.push(`  async ${method}(options: ${optionParam.type}): Promise<void> {`);
-			renderOptionsObjectDestructure(lines, pathBindings, "payload");
-			lines.push(`    await this.workos.deleteWithBody<${entityType}>(${pathStr}, ${bodyExpr});`);
+			lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): Promise<void> {`);
+			renderOptionsObjectDestructure(lines, [...pathBindings, ...queryBindings], "payload");
+			const bodyParam = renderOptionsObjectBodyFieldMap(lines, bodyFieldMap);
+			bodyExpr = bodyArgExprWithParam(bodyExpr, bodyParam);
+			lines.push(`    await this.workos.deleteWithBody<${entityType}>(${pathStr}, ${bodyExpr}${queryOptionsArg});`);
 			lines.push("  }");
 			return true;
 		}
 		if (!responseModel) {
-			lines.push(`  async ${method}(options: ${optionParam.type}): Promise<void> {`);
-			renderOptionsObjectDestructure(lines, pathBindings, "payload");
-			lines.push(`    await this.workos.${op.httpMethod}<void, ${entityType}>(${pathStr}, ${bodyExpr});`);
+			lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): Promise<void> {`);
+			renderOptionsObjectDestructure(lines, [...pathBindings, ...queryBindings], "payload");
+			const bodyParam = renderOptionsObjectBodyFieldMap(lines, bodyFieldMap);
+			bodyExpr = bodyArgExprWithParam(bodyExpr, bodyParam);
+			lines.push(`    await this.workos.${op.httpMethod}<void, ${entityType}>(${pathStr}, ${bodyExpr}${queryOptionsArg});`);
 			lines.push("  }");
 			return true;
 		}
 		const returnType = plan.isArrayResponse ? `${responseModel}[]` : responseModel;
+		const methodReturnType = override?.returnType ?? `Promise<${returnType}>`;
 		const wireType = plan.isArrayResponse ? `${wireInterfaceName(responseModel)}[]` : wireInterfaceName(responseModel);
 		const returnExpr = plan.isArrayResponse ? `data.map(deserialize${responseModel})` : `deserialize${responseModel}(data)`;
-		lines.push(`  async ${method}(options: ${optionParam.type}): Promise<${returnType}> {`);
-		renderOptionsObjectDestructure(lines, pathBindings, "payload");
+		const finalReturnExpr = override?.returnDataProperty ? `${returnExpr}.${override.returnDataProperty}` : returnExpr;
+		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${methodReturnType} {`);
+		renderOptionsObjectDestructure(lines, [...pathBindings, ...queryBindings], "payload");
+		const bodyParam = renderOptionsObjectBodyFieldMap(lines, bodyFieldMap);
+		bodyExpr = bodyArgExprWithParam(bodyExpr, bodyParam);
 		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}, ${entityType}>(`);
 		lines.push(`      ${pathStr},`);
-		lines.push(`      ${bodyExpr},`);
+		lines.push(`      ${bodyExpr}${queryOptionsArg},`);
 		lines.push("    );");
-		lines.push(`    return ${returnExpr};`);
+		if (override?.returnExpression) {
+			lines.push(`    const result = ${returnExpr};`);
+			lines.push(`    return ${override.returnExpression};`);
+		} else lines.push(`    return ${finalReturnExpr};`);
 		lines.push("  }");
 		return true;
 	}
 	if (responseModel) {
 		const returnType = plan.isArrayResponse ? `${responseModel}[]` : responseModel;
+		const methodReturnType = override?.returnType ?? `Promise<${returnType}>`;
 		const wireType = plan.isArrayResponse ? `${wireInterfaceName(responseModel)}[]` : wireInterfaceName(responseModel);
 		const returnExpr = plan.isArrayResponse ? `data.map(deserialize${responseModel})` : `deserialize${responseModel}(data)`;
-		lines.push(`  async ${method}(options: ${optionParam.type}): Promise<${returnType}> {`);
+		const finalReturnExpr = override?.returnDataProperty ? `${returnExpr}.${override.returnDataProperty}` : returnExpr;
+		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${methodReturnType} {`);
 		renderOptionsObjectDestructure(lines, pathBindings);
-		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr});`);
-		lines.push(`    return ${returnExpr};`);
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${queryOptionsArg});`);
+		if (override?.returnExpression) {
+			lines.push(`    const result = ${returnExpr};`);
+			lines.push(`    return ${override.returnExpression};`);
+		} else lines.push(`    return ${finalReturnExpr};`);
 		lines.push("  }");
 		return true;
 	}
@@ -5356,6 +5647,18 @@ function renderOptionsObjectDestructure(lines, pathBindings, restName) {
 	else if (pathBindings.length > 0) lines.push(`    const { ${pathBindings.join(", ")} } = options;`);
 	else if (restName) lines.push(`    const ${restName} = options;`);
 }
+function renderOptionsObjectBodyFieldMap(lines, bodyFieldMap) {
+	const entries = Object.entries(bodyFieldMap ?? {});
+	if (entries.length === 0) return "payload";
+	lines.push("    const requestPayload = {");
+	lines.push("      ...payload,");
+	for (const [source, target] of entries) lines.push(`      ${target}: payload.${source},`);
+	lines.push("    };");
+	return "requestPayload";
+}
+function bodyArgExprWithParam(bodyExpr, paramName) {
+	return paramName === "payload" ? bodyExpr : bodyExpr.replace(/\bpayload\b/g, paramName);
+}
 function buildOptionsObjectPathBindings(op, optionType, ctx) {
 	return op.pathParams.map((param) => resolveOptionsObjectField$1(fieldName$6(param.name), optionType, ctx));
 }
@@ -5634,6 +5937,20 @@ function renderQueryExpr(queryParams) {
 	}
 	return `options ? { ${parts.join(", ")} } : undefined`;
 }
+function renderQueryExprWithOptions(queryParams, optional, resolvedOp) {
+	const parts = [];
+	for (const param of queryParams) {
+		const camel = fieldName$6(param.name);
+		const snake = wireFieldName(param.name);
+		const access = optional ? `options?.${camel}` : `options.${camel}`;
+		if (param.required) parts.push(`${snake}: ${access}`);
+		else parts.push(`...(${access} !== undefined && { ${snake}: ${access} })`);
+	}
+	for (const [key, value] of Object.entries(getOpDefaults(resolvedOp))) parts.push(`${key}: ${tsLiteral(value)}`);
+	for (const field of getOpInferFromClient(resolvedOp)) parts.push(`${field}: ${clientFieldExpression$8(field)}`);
+	if (parts.length === 0) return optional ? "options" : "{}";
+	return `{ ${parts.join(", ")} }`;
+}
 function buildPathStr(op, paramNameMap) {
 	return buildNodePathExpression(op.path, paramNameMap);
 }
@@ -6074,6 +6391,17 @@ function generateModels$7(models, ctx, shared) {
 	const discriminatedSkip = ctx._discriminatedModelNames;
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
 	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+	for (const originalModel of models) {
+		const model = projectedByName.get(originalModel.name) ?? originalModel;
+		if (!reachableModels.has(model.name)) continue;
+		if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
+		if (!isNodeOwnedService(ctx, modelToService.get(model.name)) && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
+		const canonicalName = dedup.get(model.name);
+		if (canonicalName) {
+			forceGenerate.add(canonicalName);
+			if (interfaceEligibleModels) interfaceEligibleModels.add(canonicalName);
+		}
+	}
 	for (const originalModel of models) {
 		const model = projectedByName.get(originalModel.name) ?? originalModel;
 		if (!reachableModels.has(model.name)) continue;
@@ -6200,9 +6528,11 @@ function generateModels$7(models, ctx, shared) {
 		}
 		for (const dep of deps.models) {
 			const depName = resolveInterfaceName(dep, ctx);
-			const depDir = resolveDir(modelToService.get(dep));
+			const depService = modelToService.get(dep);
+			const depDir = resolveDir(depService);
+			const depIsOwned = isNodeOwnedService(ctx, depService);
 			const currentFilePath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
-			const baselineSrc = (ctx.apiSurface?.interfaces?.[depName])?.sourceFile;
+			const baselineSrc = depIsOwned ? void 0 : (ctx.apiSurface?.interfaces?.[depName])?.sourceFile;
 			if (baselineSrc === currentFilePath) continue;
 			let relPath;
 			if (baselineSrc) relPath = relativeImport(currentFilePath, baselineSrc).replace(/\.ts$/, "");
@@ -6385,6 +6715,7 @@ function generateSerializers(models, ctx, shared) {
 	const resourceUsage = buildGeneratedResourceModelUsage(models, ctx);
 	const serializerEligibleModels = resourceUsage ? expandModelRoots(resourceUsage.serializerRoots, projectedByName) : void 0;
 	const responseReachableModels = resourceUsage ? expandModelRoots(resourceUsage.responseRoots, projectedByName) : void 0;
+	const requestReachableModels = resourceUsage ? expandModelRoots(resourceUsage.requestRoots, projectedByName) : void 0;
 	const serializerReachable = computeNonEventReachable(ctx.spec.services, models);
 	const liveRoot = ctx.targetDir ?? ctx.outputDir;
 	if (liveRoot) for (const originalModel of models) {
@@ -6417,6 +6748,17 @@ function generateSerializers(models, ctx, shared) {
 	const discriminatedSerializerSkip = ctx._discriminatedModelNames;
 	const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
 	const serializerListMetadataNeeded = collectReferencedListMetadataModels(models, serializerNonPaginatedRefs);
+	for (const originalModel of models) {
+		const model = projectedByName.get(originalModel.name) ?? originalModel;
+		if (!serializerReachable.has(model.name)) continue;
+		if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
+		if (!isNodeOwnedService(ctx, modelToService.get(model.name)) && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
+		const canonicalName = dedup.get(model.name);
+		if (canonicalName) {
+			forceGenerateSerializer.add(canonicalName);
+			if (serializerEligibleModels) serializerEligibleModels.add(canonicalName);
+		}
+	}
 	const eligibleModels = [];
 	for (const originalModel of models) {
 		const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -6435,7 +6777,7 @@ function generateSerializers(models, ctx, shared) {
 		const responseName = wireInterfaceName(domainName);
 		const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
 		const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
-		if (shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, dedup, skippedSerializeModels, ctx)) skippedSerializeModels.add(model.name);
+		if (requestReachableModels !== void 0 && !requestReachableModels.has(model.name) || shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, dedup, skippedSerializeModels, ctx)) skippedSerializeModels.add(model.name);
 	}
 	for (const model of eligibleModels) {
 		const service = modelToService.get(model.name);
@@ -6451,20 +6793,24 @@ function generateSerializers(models, ctx, shared) {
 			const canonSerializerPath = `src/${canonDir}/serializers/${fileName$3(canonicalName)}.serializer.ts`;
 			if (serializerPath === canonSerializerPath) continue;
 			if (domainName === canonDomainName) continue;
-			const rel = relativeImport(serializerPath, canonSerializerPath);
-			const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
-			const canonSkipDeserialize = responseReachableModels !== void 0 && !responseReachableModels.has(canonicalName) && !responseReachableModels.has(model.name);
-			if (canonSkipSerialize && canonSkipDeserialize) continue;
-			const parts = [];
-			if (!canonSkipDeserialize) parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
-			if (!canonSkipSerialize) parts.push(`serialize${canonDomainName} as serialize${domainName}`);
-			const reexportContent = `export { ${parts.join(", ")} } from '${rel}';`;
-			files.push({
-				path: serializerPath,
-				content: reexportContent,
-				overwriteExisting: true
-			});
-			continue;
+			const aliasNeedsDeserialize = responseReachableModels === void 0 || responseReachableModels.has(model.name);
+			const canonicalHasDeserialize = responseReachableModels === void 0 || responseReachableModels.has(canonicalName);
+			if (!aliasNeedsDeserialize || canonicalHasDeserialize) {
+				const rel = relativeImport(serializerPath, canonSerializerPath);
+				const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
+				const canonSkipDeserialize = responseReachableModels !== void 0 && !responseReachableModels.has(canonicalName) && !responseReachableModels.has(model.name);
+				if (canonSkipSerialize && canonSkipDeserialize) continue;
+				const parts = [];
+				if (!canonSkipDeserialize) parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
+				if (!canonSkipSerialize) parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+				const reexportContent = `export { ${parts.join(", ")} } from '${rel}';`;
+				files.push({
+					path: serializerPath,
+					content: reexportContent,
+					overwriteExisting: true
+				});
+				continue;
+			}
 		}
 		const dirName = resolveDir(service);
 		const isDedupCanonical = [...dedup.values()].includes(model.name);
@@ -6504,7 +6850,7 @@ function generateSerializers(models, ctx, shared) {
 	}
 	const liveRootForBarrel = ctx.outputDir ?? ctx.targetDir;
 	for (const [dir, stems] of serializersByDir) {
-		if (liveRootForBarrel) {
+		if (liveRootForBarrel && !isNodeOwnedService(ctx, dir)) {
 			const serializersDir = path.join(liveRootForBarrel, "src", dir, "serializers");
 			try {
 				for (const entry of fs.readdirSync(serializersDir)) {
@@ -6750,6 +7096,25 @@ function generateWorkOSClient$1(spec, ctx) {
 		skipIfExists: true
 	};
 }
+function sourceFileForExportedType(ctx, typeName) {
+	return (ctx.apiSurface?.interfaces?.[typeName])?.sourceFile ?? (ctx.apiSurface?.typeAliases?.[typeName])?.sourceFile ?? (ctx.apiSurface?.enums?.[typeName])?.sourceFile ?? liveSurfaceInterfacePath(typeName);
+}
+function exportedNamesForSource(ctx, sourceFile) {
+	const names = /* @__PURE__ */ new Set();
+	const addNamesFromSurface = (items) => {
+		if (!items) return;
+		for (const [name, item] of Object.entries(items)) if (item.sourceFile === sourceFile) names.add(name);
+	};
+	addNamesFromSurface(ctx.apiSurface?.interfaces);
+	addNamesFromSurface(ctx.apiSurface?.typeAliases);
+	addNamesFromSurface(ctx.apiSurface?.enums);
+	const rootDir = ctx.targetDir ?? ctx.outputDir;
+	if (rootDir) try {
+		const content = fs.readFileSync(path.join(rootDir, sourceFile), "utf-8");
+		for (const match of content.matchAll(/export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/g)) names.add(match[1]);
+	} catch {}
+	return [...names];
+}
 /**
 * Generate per-service barrel files (interfaces/index.ts) that re-export
 * all interface and enum files for each service directory. This reduces
@@ -6762,11 +7127,14 @@ function generateServiceBarrels(spec, ctx) {
 	const enumToService = assignEnumsToServices(spec.enums, spec.services, spec.models, ctx);
 	const dirExports = /* @__PURE__ */ new Map();
 	const dirSymbols = /* @__PURE__ */ new Map();
+	const ownedDirNames = /* @__PURE__ */ new Set();
+	for (const service of spec.services) if (isNodeOwnedService(ctx, service.name)) ownedDirNames.add(resolveDir(service.name));
 	const dirSymbolsFromBaseline = /* @__PURE__ */ new Map();
 	const seedFromBaseline = (sourceFile, name) => {
 		const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
 		if (!match) return;
 		const dirName = match[1];
+		if (ownedDirNames.has(dirName)) return;
 		const fileStem = match[2];
 		if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
 		dirSymbols.get(dirName).add(name);
@@ -6819,9 +7187,63 @@ function generateServiceBarrels(spec, ctx) {
 		globalExistingSymbols.add(enumDef.name);
 		dirExports.get(dirName).push(`export * from './${fileName$3(enumDef.name)}.interface';`);
 	}
+	const overrideWildcardSources = /* @__PURE__ */ new Set();
+	const overrideNamedExports = /* @__PURE__ */ new Set();
+	const addOverrideTypeExport = (typeName) => {
+		if (!typeName) return;
+		const sourceFile = sourceFileForExportedType(ctx, typeName);
+		if (!sourceFile) return;
+		const match = sourceFile?.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+		if (!match) return;
+		const dirName = match[1];
+		const stem = match[2].replace(/\.ts$/, "");
+		if (!dirExports.has(dirName)) {
+			dirExports.set(dirName, []);
+			if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+		}
+		const symbols = dirSymbols.get(dirName);
+		const sourceKey = `${dirName}/${stem}`;
+		if (overrideWildcardSources.has(sourceKey)) return;
+		const sourceNames = exportedNamesForSource(ctx, sourceFile);
+		if (sourceNames.some((name) => name !== typeName && globalExistingSymbols.has(name))) {
+			const exportKey = `${sourceKey}:${typeName}`;
+			if (overrideNamedExports.has(exportKey)) return;
+			dirExports.get(dirName).push(`export type { ${typeName} } from './${stem}';`);
+			overrideNamedExports.add(exportKey);
+			symbols.add(typeName);
+			globalExistingSymbols.add(typeName);
+			return;
+		}
+		dirExports.get(dirName).push(`export * from './${stem}';`);
+		overrideWildcardSources.add(sourceKey);
+		const namesToRegister = sourceNames.length > 0 ? sourceNames : [typeName];
+		for (const name of namesToRegister) {
+			symbols.add(name);
+			globalExistingSymbols.add(name);
+		}
+	};
+	for (const override of Object.values(nodeOptions(ctx).operationOverrides ?? {})) {
+		addOverrideTypeExport(override.optionsType);
+		for (const typeName of override.returnTypeImports ?? []) addOverrideTypeExport(typeName);
+	}
+	const generatedOptionExports = ctx._nodeGeneratedOptionInterfaceExports;
+	for (const [dirName, options] of generatedOptionExports ?? []) {
+		if (!dirExports.has(dirName)) {
+			dirExports.set(dirName, []);
+			if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, /* @__PURE__ */ new Set());
+		}
+		const symbols = dirSymbols.get(dirName);
+		for (const { stem, typeName } of options) {
+			if (globalExistingSymbols.has(typeName)) continue;
+			symbols.add(typeName);
+			globalExistingSymbols.add(typeName);
+			dirExports.get(dirName).push(`export * from './${stem}';`);
+		}
+	}
 	for (const [dirName, exports] of dirExports) {
 		const exportSet = new Set(exports);
-		if (ctx.apiSurface) {
+		const isDirOwned = ownedDirNames.has(dirName);
+		if (ctx.apiSurface && !isDirOwned) {
 			const addBaselineExports = (items) => {
 				if (!items) return;
 				for (const item of Object.values(items)) {
@@ -6834,7 +7256,7 @@ function generateServiceBarrels(spec, ctx) {
 			addBaselineExports(ctx.apiSurface.interfaces);
 			addBaselineExports(ctx.apiSurface.typeAliases);
 			addBaselineExports(ctx.apiSurface.enums);
-			if (ctx.targetDir) {
+			if (ctx.targetDir && !isDirOwned) {
 				const interfacesDir = path.join(ctx.targetDir, "src", dirName, "interfaces");
 				try {
 					const barrelPath = path.join(interfacesDir, "index.ts");
@@ -7088,6 +7510,9 @@ function serverConstName(description) {
 }
 //#endregion
 //#region src/node/tests.ts
+function operationOverrideFor(ctx, op) {
+	return nodeOptions(ctx).operationOverrides?.[`${op.httpMethod.toUpperCase()} ${op.path}`];
+}
 function baselineMethodFor(service, method, ctx) {
 	const serviceClass = resolveResourceClassName$3(service, ctx);
 	return ctx.apiSurface?.classes?.[serviceClass]?.methods?.[method]?.[0];
@@ -7103,6 +7528,34 @@ function optionsObjectParam(method) {
 		type: param.type
 	};
 }
+function configuredOptionsMethod(ctx, op) {
+	const optionsType = operationOverrideFor(ctx, op)?.optionsType;
+	if (!optionsType) return void 0;
+	return { params: [{
+		name: "options",
+		type: optionsType,
+		passingStyle: "options_object"
+	}] };
+}
+function methodOptionsName(method, serviceClass) {
+	if (method === "list") return `${toPascalCase(serviceClass)}ListOptions`;
+	return `${toPascalCase(method)}Options`;
+}
+function hasOptionsInput(op, plan) {
+	return op.pathParams.length > 0 || plan.hasBody || plan.isPaginated || op.queryParams.length > 0;
+}
+function optionsMethodFor(service, method, op, plan, ctx) {
+	const baseline = baselineMethodFor(service, method, ctx);
+	if (optionsObjectParam(baseline)) return baseline;
+	const configured = configuredOptionsMethod(ctx, op);
+	if (configured) return configured;
+	if (!hasOptionsInput(op, plan)) return baseline;
+	return { params: [{
+		name: "options",
+		type: methodOptionsName(method, resolveResourceClassName$3(service, ctx)),
+		passingStyle: "options_object"
+	}] };
+}
 function autoPaginatableItemType(returnType) {
 	return returnType?.match(/\bAutoPaginatable<\s*([A-Za-z_$][\w$]*)/)?.[1];
 }
@@ -7212,7 +7665,7 @@ function generateServiceTest$3(service, spec, ctx, modelMap, mountAccessors) {
 	lines.push(`describe('${serviceClass}', () => {`);
 	lines.push("  beforeEach(() => fetch.resetMocks());");
 	for (const { op, plan, method } of plans) {
-		const existingMethod = baselineMethodFor(service, method, ctx);
+		const existingMethod = optionsMethodFor(service, method, op, plan, ctx);
 		lines.push("");
 		lines.push(`  describe('${method}', () => {`);
 		if (plan.isPaginated) renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap, ctx, entityHelperNames, existingMethod);
@@ -7329,6 +7782,12 @@ function renderBodyTest(lines, op, plan, method, serviceProp, modelMap, ctx, ent
 	if (payload) lines.push(`      expect(fetchBody()).toEqual(expect.objectContaining(${payload.snakeCaseObj}));`);
 	else lines.push("      expect(fetchBody()).toBeDefined();");
 	if (isArrayResponse) lines.push("      expect(Array.isArray(result)).toBe(true);");
+	const override = ctx ? operationOverrideFor(ctx, op) : void 0;
+	if (override?.returnExpression || override?.returnDataProperty) {
+		lines.push("      expect(result).toBeDefined();");
+		lines.push("    });");
+		return;
+	}
 	const bodyHelperName = ctx ? `expect${resolveInterfaceName(responseModelName, ctx)}` : null;
 	if (bodyHelperName && entityHelpers?.has(bodyHelperName)) lines.push(`      ${bodyHelperName}(${accessor});`);
 	else {
@@ -7358,6 +7817,13 @@ function renderGetTest(lines, op, plan, method, serviceProp, modelMap, ctx, enti
 	const expectedPathGet = buildExpectedPath$4(op);
 	lines.push(`      expect(new URL(String(fetchURL())).pathname).toBe('${expectedPathGet}');`);
 	if (isArrayResponse) lines.push("      expect(Array.isArray(result)).toBe(true);");
+	const returnDataProperty = ctx ? operationOverrideFor(ctx, op)?.returnDataProperty : void 0;
+	if (returnDataProperty) {
+		if ((modelMap.get(responseModelName)?.fields.find((field) => fieldName$6(field.name) === returnDataProperty))?.type.kind === "array") lines.push("      expect(Array.isArray(result)).toBe(true);");
+		else lines.push("      expect(result).toBeDefined();");
+		lines.push("    });");
+		return;
+	}
 	const helperName = ctx ? `expect${resolveInterfaceName(responseModelName, ctx)}` : null;
 	if (helperName && entityHelpers?.has(helperName)) lines.push(`      ${helperName}(${accessor});`);
 	else {
@@ -7395,12 +7861,37 @@ function buildOptionsObjectTestArg(op, plan, baselineMethod, modelMap, ctx) {
 		const optionField = resolveOptionsObjectField(localName, optionParam.type, ctx);
 		entries.push(`${optionField}: ${JSON.stringify(pathParamTestValue(param, localName))}`);
 	}
+	if (plan.isPaginated) entries.push("order: 'desc'");
+	const queryParams = plan.isPaginated ? op.queryParams.filter((param) => ![
+		"limit",
+		"before",
+		"after",
+		"order"
+	].includes(param.name)) : op.queryParams;
+	for (const param of queryParams) {
+		const localName = fieldName$6(param.name);
+		const value = fixtureValueForType(param.type, param.name, "Options", modelMap) ?? "'test'";
+		entries.push(`${localName}: ${value}`);
+	}
 	if (plan.hasBody) {
 		const payload = buildTestPayload(op, modelMap);
-		if (payload) entries.push(...objectLiteralEntries(payload.camelCaseObj));
+		if (payload) {
+			const bodyFieldMap = ctx ? operationOverrideFor(ctx, op)?.bodyFieldMap : void 0;
+			entries.push(...mapBodyOptionEntries(objectLiteralEntries(payload.camelCaseObj), bodyFieldMap));
+		} else if (entries.length === 0) return "({} as any)";
 	}
 	return `{ ${entries.join(", ")} }`;
 }
+function mapBodyOptionEntries(entries, bodyFieldMap) {
+	const reverseMap = new Map(Object.entries(bodyFieldMap ?? {}).map(([source, target]) => [target, source]));
+	if (reverseMap.size === 0) return entries;
+	return entries.map((entry) => {
+		const match = entry.match(/^([A-Za-z_$][\w$]*)\s*:/);
+		if (!match) return entry;
+		const source = reverseMap.get(match[1]);
+		return source ? entry.replace(match[1], source) : entry;
+	});
+}
 function objectLiteralEntries(literal) {
 	const trimmed = literal.trim();
 	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return [];
@@ -7476,7 +7967,8 @@ function buildFieldAssertions(model, accessor, modelMap) {
 	for (const field of model.fields) {
 		if (!field.required) continue;
 		const domainField = fieldName$6(field.name);
-		const fieldAccessor = isDateTimeFieldType(field.type) ? `${accessor}.${domainField}.toISOString()` : `${accessor}.${domainField}`;
+		const isDateTime = isDateTimeFieldType(field.type);
+		const fieldAccessor = isDateTime ? `${accessor}.${domainField}.toISOString()` : `${accessor}.${domainField}`;
 		if (field.example !== void 0) {
 			if (field.example === null) {
 				assertions.push(`expect(${accessor}.${domainField}).toBeNull();`);
@@ -7484,7 +7976,7 @@ function buildFieldAssertions(model, accessor, modelMap) {
 			}
 			if (typeof field.example === "object") assertions.push(`expect(${accessor}.${domainField}).toEqual(${JSON.stringify(field.example)});`);
 			else {
-				const exampleLiteral = typeof field.example === "string" ? `'${field.example}'` : String(field.example);
+				const exampleLiteral = isDateTime && typeof field.example === "string" ? `'${new Date(field.example).toISOString()}'` : typeof field.example === "string" ? `'${field.example}'` : String(field.example);
 				assertions.push(`expect(${fieldAccessor}).toBe(${exampleLiteral});`);
 			}
 			continue;
@@ -7513,7 +8005,7 @@ function buildFieldAssertions(model, accessor, modelMap) {
 */
 function fixtureValueForType(ref, name, modelName, modelMap, wire) {
 	switch (ref.kind) {
-		case "primitive": return fixtureValueForPrimitive(ref.type, ref.format, name, modelName);
+		case "primitive": return fixtureValueForPrimitive(ref.type, ref.format, name, modelName, wire);
 		case "literal": return typeof ref.value === "string" ? `'${ref.value}'` : String(ref.value);
 		case "enum":
 			if (ref.values?.length) {
@@ -7543,10 +8035,10 @@ function fixtureValueForType(ref, name, modelName, modelMap, wire) {
 		default: return null;
 	}
 }
-function fixtureValueForPrimitive(type, format, name, modelName) {
+function fixtureValueForPrimitive(type, format, name, modelName, wire) {
 	switch (type) {
 		case "string":
-			if (format === "date-time") return "'2023-01-01T00:00:00.000Z'";
+			if (format === "date-time") return wire ? "'2023-01-01T00:00:00.000Z'" : "new Date('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$4[modelName] ?? ""}01234'`;
@@ -7771,11 +8263,14 @@ function detectDiscriminatedShape(modelName, rawSchemas) {
 		};
 	}).filter((v) => v !== null);
 	if (variants.length !== flattenedVariants.length) return null;
+	const baseFields = baseObject ? collectObjectFields(baseObject, modelName) : [];
+	const discriminatorDescription = flattenedVariants[0].alwaysProperties.get(discProp)?.description;
 	return {
 		modelName,
-		baseFields: baseObject ? collectObjectFields(baseObject, modelName) : [],
+		baseFields,
 		discriminatorProperty: discProp,
 		discriminatorPropertyDomain: toCamelCase(discProp),
+		discriminatorDescription,
 		variants
 	};
 }
@@ -8052,6 +8547,7 @@ function buildInterfaceBody(name, shape, variant, isWire) {
 	lines.push(`export interface ${name} {`);
 	for (const field of shape.baseFields) pushFieldLine(lines, field, isWire);
 	const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
+	if (shape.discriminatorDescription) lines.push(`  /** ${shape.discriminatorDescription} */`);
 	lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
 	for (const field of variant.fields) pushFieldLine(lines, field, isWire);
 	lines.push("}");
@@ -8180,20 +8676,6 @@ function scalarModelDepName(field) {
 }
 //#endregion
 //#region src/node/node-overrides.ts
-const OPERATION_OVERRIDES = {
-	"POST /organizations/{organizationId}/groups": { methodName: "create_group" },
-	"GET /organizations/{organizationId}/groups": { methodName: "list_groups" },
-	"GET /organizations/{organizationId}/groups/{groupId}": { methodName: "get_group" },
-	"PATCH /organizations/{organizationId}/groups/{groupId}": { methodName: "update_group" },
-	"DELETE /organizations/{organizationId}/groups/{groupId}": { methodName: "delete_group" },
-	"POST /organizations/{organizationId}/groups/{groupId}/organization-memberships": { methodName: "add_organization_membership" },
-	"GET /organizations/{organizationId}/groups/{groupId}/organization-memberships": { methodName: "list_organization_memberships" },
-	"DELETE /organizations/{organizationId}/groups/{groupId}/organization-memberships/{omId}": { methodName: "remove_organization_membership" },
-	"GET /user_management/organization_memberships/{omId}/groups": {
-		methodName: "list_groups_for_organization_membership",
-		mountOn: "UserManagement"
-	}
-};
 const contextCache = /* @__PURE__ */ new WeakMap();
 function operationKey(resolved) {
 	return `${resolved.operation.httpMethod.toUpperCase()} ${resolved.operation.path}`;
@@ -8245,9 +8727,10 @@ function withNodeOperationOverrides(ctx) {
 		contextCache.set(ctx, next);
 		return next;
 	}
+	const configOverrides = nodeOptions(ctx).operationOverrides ?? {};
 	let opsChanged = false;
 	const nextResolved = resolvedOperations.map((resolved) => {
-		const override = OPERATION_OVERRIDES[operationKey(resolved)];
+		const override = configOverrides[operationKey(resolved)];
 		if (!override) return resolved;
 		const methodName = override.methodName ?? resolved.methodName;
 		const mountOn = override.mountOn ?? resolved.mountOn;
@@ -8475,20 +8958,48 @@ function isOwnedPath(relPath, policy) {
 	const dir = topLevelDir(relPath);
 	return dir !== void 0 && policy.ownedServiceDirs.has(dir);
 }
+function extractRelativeImportPaths(content, fromPath) {
+	const dir = path$1.dirname(fromPath);
+	const paths = [];
+	const re = /from\s+['"](\.[^'"]+)['"]/g;
+	let match;
+	while ((match = re.exec(content)) !== null) paths.push(path$1.normalize(path$1.join(dir, match[1])) + ".ts");
+	return paths;
+}
 function applyLiveSurface(files, ctx, surface) {
 	const out = [];
 	const policy = buildLiveSurfacePolicy(ctx, surface);
+	const filesByPath = new Map(files.map((f) => [f.path, f]));
+	const dependencyAllowedPaths = /* @__PURE__ */ new Set();
+	const queue = [];
+	for (const f of files) {
+		if (f.integrateTarget === false) continue;
+		if (!canCreateNewPath(f.path, policy)) continue;
+		for (const importPath of extractRelativeImportPaths(f.content, f.path)) if (filesByPath.has(importPath) && !canCreateNewPath(importPath, policy) && !dependencyAllowedPaths.has(importPath)) {
+			dependencyAllowedPaths.add(importPath);
+			queue.push(importPath);
+		}
+	}
+	while (queue.length > 0) {
+		const relPath = queue.pop();
+		const file = filesByPath.get(relPath);
+		if (!file) continue;
+		for (const importPath of extractRelativeImportPaths(file.content, relPath)) if (filesByPath.has(importPath) && !canCreateNewPath(importPath, policy) && !dependencyAllowedPaths.has(importPath)) {
+			dependencyAllowedPaths.add(importPath);
+			queue.push(importPath);
+		}
+	}
 	for (const f of files) {
 		const ownedPath = isOwnedPath(f.path, policy);
 		if (f.integrateTarget === false) continue;
 		if (surface.protectedFiles.has(f.path)) continue;
-		if (policy.hasExistingSdk && !policy.managedPaths.has(f.path) && !canCreateNewPath(f.path, policy)) continue;
+		if (policy.hasExistingSdk && !policy.managedPaths.has(f.path) && !canCreateNewPath(f.path, policy) && !dependencyAllowedPaths.has(f.path)) continue;
 		if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path) && !ownedPath) continue;
 		if (isUserOwnedAfterFirstEmit(f.path)) {
 			const dir = topLevelDir(f.path);
 			const isAdoptedDir = dir !== void 0 && policy.adoptedServiceDirs.has(dir);
 			const isManagedDir = ownedPath || isAdoptedDir;
-			if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path)) continue;
+			if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path) && !(ownedPath && policy.regenerateOwnedTests)) continue;
 			if (!isManagedDir && !surface.autogenFiles.has(f.path)) continue;
 			if (isManagedDir && !policy.regenerateOwnedTests) continue;
 		}
@@ -8582,7 +9093,9 @@ const nodeEmitter = {
 		const surface = getSurface(nodeCtx);
 		const enriched = enrichModelsForNode(models);
 		const discPlans = planDiscriminatedModels(enriched, nodeCtx);
-		nodeCtx._discriminatedModelNames = new Set(discPlans.keys());
+		const discriminatedNames = new Set(discPlans.keys());
+		nodeCtx._discriminatedModelNames = discriminatedNames;
+		setDiscriminatedModelNames(discriminatedNames);
 		const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
 		const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
 		return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);
@@ -9195,11 +9708,24 @@ function generateEnums$6(enums, ctx) {
 			const canonicalCls = className$5(canonicalName);
 			const aliasCls = className$5(enumDef.name);
 			const lines = [];
-			lines.push("from typing import TypeAlias");
-			if (canonicalDir === dirName) lines.push(`from .${fileName$2(canonicalName)} import ${canonicalCls}`);
-			else lines.push(`from ${ctx.namespace}.${dirToModule(canonicalDir)}.models.${fileName$2(canonicalName)} import ${canonicalCls}`);
-			lines.push("");
-			lines.push(`${aliasCls}: TypeAlias = ${canonicalCls}`);
+			if (canonicalDir === dirName) {
+				lines.push("from typing import TypeAlias");
+				lines.push(`from .${fileName$2(canonicalName)} import ${canonicalCls}`);
+				lines.push("");
+				lines.push(`${aliasCls}: TypeAlias = ${canonicalCls}`);
+			} else {
+				const modPath = `${ctx.namespace}.${dirToModule(canonicalDir)}.models.${fileName$2(canonicalName)}`;
+				lines.push("from typing import TYPE_CHECKING");
+				lines.push("");
+				lines.push("if TYPE_CHECKING:");
+				lines.push(`    from ${modPath} import ${canonicalCls} as ${aliasCls}`);
+				lines.push("else:");
+				lines.push("    def __getattr__(name: str):");
+				lines.push(`        if name == "${aliasCls}":`);
+				lines.push(`            from ${modPath} import ${canonicalCls}`);
+				lines.push(`            return ${canonicalCls}`);
+				lines.push("        raise AttributeError(f\"module {__name__!r} has no attribute {name!r}\")");
+			}
 			lines.push(`__all__ = ["${aliasCls}"]`);
 			files.push({
 				path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(enumDef.name)}.py`,
@@ -9208,16 +9734,33 @@ function generateEnums$6(enums, ctx) {
 				overwriteExisting: true
 			});
 			for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
-				const importLine = canonicalDir === dirName ? `from .${fileName$2(canonicalName)} import ${canonicalCls}` : `from ${ctx.namespace}.${dirToModule(canonicalDir)}.models.${fileName$2(canonicalName)} import ${canonicalCls}`;
-				files.push({
-					path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(aliasName)}.py`,
-					content: [
-						"from typing import TypeAlias",
-						importLine,
+				let compatContent;
+				if (canonicalDir === dirName) compatContent = [
+					"from typing import TypeAlias",
+					`from .${fileName$2(canonicalName)} import ${canonicalCls}`,
+					"",
+					`${aliasName}: TypeAlias = ${canonicalCls}`,
+					`__all__ = ["${aliasName}"]`
+				].join("\n");
+				else {
+					const modPath = `${ctx.namespace}.${dirToModule(canonicalDir)}.models.${fileName$2(canonicalName)}`;
+					compatContent = [
+						"from typing import TYPE_CHECKING",
 						"",
-						`${aliasName}: TypeAlias = ${canonicalCls}`,
+						"if TYPE_CHECKING:",
+						`    from ${modPath} import ${canonicalCls} as ${aliasName}`,
+						"else:",
+						"    def __getattr__(name: str):",
+						`        if name == "${aliasName}":`,
+						`            from ${modPath} import ${canonicalCls}`,
+						`            return ${canonicalCls}`,
+						"        raise AttributeError(f\"module {__name__!r} has no attribute {name!r}\")",
 						`__all__ = ["${aliasName}"]`
-					].join("\n"),
+					].join("\n");
+				}
+				files.push({
+					path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(aliasName)}.py`,
+					content: compatContent,
 					integrateTarget: true,
 					overwriteExisting: true
 				});
@@ -9391,6 +9934,8 @@ function generateModels$6(models, ctx) {
 	const emittedFilePaths = /* @__PURE__ */ new Set();
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
 	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+	const discriminatorNames = /* @__PURE__ */ new Set();
+	for (const m of models) if (m.discriminator) discriminatorNames.add(m.name);
 	for (const model of models) {
 		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
@@ -9526,7 +10071,7 @@ function generateModels$6(models, ctx) {
 		typingImports.add("Dict");
 		for (const field of deduplicatedFields) collectTypingImports(field.type, typingImports);
 		if (deduplicatedFields.some((f) => isOptionalField(model.name, f, ctx))) typingImports.add("Optional");
-		const usesDateTime = deduplicatedFields.some((f) => isDateTimeType(f.type));
+		const usesDateTime = deduplicatedFields.some((f) => isDateTimeType$1(f.type));
 		const usesEnum = deps.enums.size > 0;
 		lines.push("from __future__ import annotations");
 		lines.push("");
@@ -9542,8 +10087,9 @@ function generateModels$6(models, ctx) {
 			for (const modelName of [...deps.models].sort()) {
 				if (modelName === model.name) continue;
 				const modelDir = resolveDir(modelToService.get(modelName));
-				if (modelDir === dirName) lines.push(`from .${fileName$2(modelName)} import ${className$5(modelName)}`);
-				else lines.push(`from ${ctx.namespace}.${dirToModule(modelDir)}.models.${fileName$2(modelName)} import ${className$5(modelName)}`);
+				const importNames = discriminatorNames.has(modelName) ? `${className$5(modelName)}, ${className$5(modelName)}Variant` : className$5(modelName);
+				if (modelDir === dirName) lines.push(`from .${fileName$2(modelName)} import ${importNames}`);
+				else lines.push(`from ${ctx.namespace}.${dirToModule(modelDir)}.models.${fileName$2(modelName)} import ${importNames}`);
 			}
 		}
 		if (deps.enums.size > 0) for (const enumName of [...deps.enums].sort()) {
@@ -9564,9 +10110,16 @@ function generateModels$6(models, ctx) {
 		lines.push("");
 		const requiredFields = deduplicatedFields.filter((f) => !isOptionalField(model.name, f, ctx));
 		const optionalFields = deduplicatedFields.filter((f) => isOptionalField(model.name, f, ctx));
+		const rewriteDiscriminatorType = (typeStr) => {
+			for (const discName of discriminatorNames) {
+				const quoted = `"${className$5(discName)}"`;
+				if (typeStr.includes(quoted)) typeStr = typeStr.replace(quoted, `"${className$5(discName)}Variant"`);
+			}
+			return typeStr;
+		};
 		for (const field of requiredFields) {
 			const pyFieldName = fieldName$5(field.name);
-			const pyType = resolveModelFieldType(field.type);
+			const pyType = rewriteDiscriminatorType(resolveModelFieldType(field.type));
 			if (field.description || field.deprecated) {
 				const parts = [];
 				if (field.description) parts.push(field.description);
@@ -9577,7 +10130,7 @@ function generateModels$6(models, ctx) {
 		}
 		for (const field of optionalFields) {
 			const pyFieldName = fieldName$5(field.name);
-			const pyType = `Optional[${field.type.kind === "nullable" ? resolveModelFieldType(field.type.inner) : resolveModelFieldType(field.type)}]`;
+			const pyType = `Optional[${rewriteDiscriminatorType(field.type.kind === "nullable" ? resolveModelFieldType(field.type.inner) : resolveModelFieldType(field.type))}]`;
 			if (field.description || field.deprecated) {
 				const parts = [];
 				if (field.description) parts.push(field.description);
@@ -9821,12 +10374,12 @@ function pythonLiteralDefault(value) {
 	return String(value);
 }
 function resolveModelFieldType(ref) {
-	if (ref.kind === "nullable" && isDateTimeType(ref.inner)) return "Optional[datetime]";
-	if (isDateTimeType(ref)) return "datetime";
+	if (ref.kind === "nullable" && isDateTimeType$1(ref.inner)) return "Optional[datetime]";
+	if (isDateTimeType$1(ref)) return "datetime";
 	return mapTypeRef$6(ref);
 }
-function isDateTimeType(ref) {
-	if (ref.kind === "nullable") return isDateTimeType(ref.inner);
+function isDateTimeType$1(ref) {
+	if (ref.kind === "nullable") return isDateTimeType$1(ref.inner);
 	return ref.kind === "primitive" && ref.type === "string" && ref.format === "date-time";
 }
 /**
@@ -9887,7 +10440,7 @@ function renderDiscriminatedUnionPrelude(field, pyFieldName, wireKey, parentClas
 	prelude.push(`${indent}if ${rawVar} is None:`);
 	prelude.push(`${indent}    ${valueVar} = None`);
 	prelude.push(`${indent}else:`);
-	prelude.push(...dispatchBlock(indent + "    "));
+	prelude.push(...dispatchBlock("                "));
 	prelude.push(`${indent}    ${valueVar} = ${clsVar}.from_dict(${dataVar})`);
 	return {
 		prelude,
@@ -9895,7 +10448,7 @@ function renderDiscriminatedUnionPrelude(field, pyFieldName, wireKey, parentClas
 	};
 }
 function deserializeField(ref, accessor, isRequired, walrusVar = "_v") {
-	if (isDateTimeType(ref)) {
+	if (isDateTimeType$1(ref)) {
 		if (isRequired) return `_parse_datetime(${accessor})`;
 		return `_parse_datetime(${walrusVar}) if (${walrusVar} := ${accessor}) is not None else None`;
 	}
@@ -9934,7 +10487,7 @@ function deserializeField(ref, accessor, isRequired, walrusVar = "_v") {
 	}
 }
 function serializeField(ref, accessor) {
-	if (isDateTimeType(ref)) return `_format_datetime(${accessor})`;
+	if (isDateTimeType$1(ref)) return `_format_datetime(${accessor})`;
 	switch (ref.kind) {
 		case "model": return `${accessor}.to_dict()`;
 		case "enum": return `${accessor}.value if isinstance(${accessor}, Enum) else ${accessor}`;
@@ -10078,7 +10631,8 @@ function emitWrapperMethod$5(lines, resolvedOp, wrapper, ctx, isAsync) {
 		else lines.push(`        ${pyName}: ${pyType},`);
 	}
 	lines.push("        request_options: Optional[RequestOptions] = None,");
-	const responseType = wrapper.responseModelName ? className$5(wrapper.responseModelName) : "None";
+	const isDiscriminatorResponse = wrapper.responseModelName ? !!ctx.spec.models.find((m) => m.name === wrapper.responseModelName)?.discriminator : false;
+	const responseType = wrapper.responseModelName ? isDiscriminatorResponse ? className$5(wrapper.responseModelName) + "Variant" : className$5(wrapper.responseModelName) : "None";
 	lines.push(`    ) -> ${responseType}:`);
 	lines.push(`        """${formatWrapperDescription(wrapper.name)}."""`);
 	lines.push("        body: Dict[str, Any] = {");
@@ -10103,7 +10657,19 @@ function emitWrapperMethod$5(lines, resolvedOp, wrapper, ctx, isAsync) {
 	const pathExpr = buildPythonPathExpression(op.path);
 	const awaitPrefix = isAsync ? "await " : "";
 	lines.push("");
-	if (wrapper.responseModelName) {
+	if (wrapper.responseModelName && isDiscriminatorResponse) {
+		const variantType = className$5(wrapper.responseModelName) + "Variant";
+		lines.push(`        return cast(`);
+		lines.push(`            ${variantType},`);
+		lines.push(`            ${awaitPrefix}self._client.request(`);
+		lines.push(`                method="${op.httpMethod.toUpperCase()}",`);
+		lines.push(`                path=${pathExpr},`);
+		lines.push("                body=body,");
+		lines.push(`                model=${className$5(wrapper.responseModelName)},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`);
+		lines.push("                request_options=request_options,");
+		lines.push("            )");
+		lines.push("        )");
+	} else if (wrapper.responseModelName) {
 		lines.push(`        return ${awaitPrefix}self._client.request(`);
 		lines.push(`            method="${op.httpMethod.toUpperCase()}",`);
 		lines.push(`            path=${pathExpr},`);
@@ -10335,8 +10901,8 @@ function emitMethodSignature(lines, op, plan, method, isAsync, specEnumNames, mo
 	else if (isPaginated) {
 		const resolvedItem = resolvePageItemName(op.pagination.itemType, listWrapperNames, ctx);
 		returnType = `${pageType}[${ctx.spec.models.find((m) => m.name === resolvedItem)?.discriminator ? className$5(resolvedItem) + "Variant" : className$5(resolvedItem)}]`;
-	} else if (isArrayResponse) returnType = `List[${className$5(plan.responseModelName)}]`;
-	else if (plan.responseModelName) returnType = className$5(plan.responseModelName);
+	} else if (isArrayResponse) returnType = `List[${ctx.spec.models.find((m) => m.name === plan.responseModelName)?.discriminator ? className$5(plan.responseModelName) + "Variant" : className$5(plan.responseModelName)}]`;
+	else if (plan.responseModelName) returnType = ctx.spec.models.find((m) => m.name === plan.responseModelName)?.discriminator ? className$5(plan.responseModelName) + "Variant" : className$5(plan.responseModelName);
 	else returnType = "None";
 	lines.push(`    ) -> ${returnType}:`);
 	return {
@@ -10627,6 +11193,7 @@ function emitMethodBody(lines, op, plan, meta, isAsync, modelImports, listWrappe
 		lines.push("        )");
 	} else if (plan.hasBody && op.requestBody) {
 		const responseModel = plan.responseModelName ? className$5(plan.responseModelName) : "None";
+		const isBodyResponseDiscriminator = !!(plan.responseModelName ? ctx.spec.models.find((m) => m.name === plan.responseModelName) : null)?.discriminator;
 		const bodyGroupedParams = collectGroupedParamNames(op);
 		const bodyModel = ctx.spec.models.find((m) => op.requestBody?.kind === "model" && m.name === op.requestBody.name);
 		const bodyFieldNamesSet = /* @__PURE__ */ new Set();
@@ -10664,6 +11231,20 @@ function emitMethodBody(lines, op, plan, meta, isAsync, modelImports, listWrappe
 			lines.push("            request_options=request_options,");
 			lines.push("        )");
 			lines.push(`        return [${itemModel}.from_dict(cast(Dict[str, Any], item)) for item in raw]`);
+		} else if (isBodyResponseDiscriminator && responseModel !== "None") {
+			const variantType = responseModel + "Variant";
+			lines.push(`        return cast(`);
+			lines.push(`            ${variantType},`);
+			lines.push(`            ${awaitPrefix}self._client.request(`);
+			lines.push(`                method="${httpMethod}",`);
+			lines.push(`                path=${pathStr},`);
+			lines.push(`                body=${bodyVarName},`);
+			if (bodyHasParams) lines.push("                params=params,");
+			lines.push(`                model=${responseModel},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`);
+			if (plan.isIdempotentPost) lines.push("                idempotency_key=idempotency_key,");
+			lines.push("                request_options=request_options,");
+			lines.push("            )");
+			lines.push("        )");
 		} else {
 			const bodyReturnPrefix = responseModel !== "None" ? "return " : "";
 			lines.push(`        ${bodyReturnPrefix}${awaitPrefix}self._client.request(`);
@@ -10678,6 +11259,7 @@ function emitMethodBody(lines, op, plan, meta, isAsync, modelImports, listWrappe
 		}
 	} else {
 		const responseModel = plan.responseModelName ? className$5(plan.responseModelName) : "None";
+		const isGetResponseDiscriminator = !!(plan.responseModelName ? ctx.spec.models.find((m) => m.name === plan.responseModelName) : null)?.discriminator;
 		const getGroupedParams = collectGroupedParamNames(op);
 		const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
 		const visibleQueryParams = op.queryParams.filter((p) => !hiddenParams.has(p.name) && !getGroupedParams.has(p.name));
@@ -10720,6 +11302,18 @@ function emitMethodBody(lines, op, plan, meta, isAsync, modelImports, listWrappe
 			lines.push("            request_options=request_options,");
 			lines.push("        )");
 			lines.push(`        return [${itemModel}.from_dict(cast(Dict[str, Any], item)) for item in raw]`);
+		} else if (isGetResponseDiscriminator && responseModel !== "None") {
+			const variantType = responseModel + "Variant";
+			lines.push(`        return cast(`);
+			lines.push(`            ${variantType},`);
+			lines.push(`            ${awaitPrefix}self._client.request(`);
+			lines.push(`                method="${httpMethod}",`);
+			lines.push(`                path=${pathStr},`);
+			if (emittedParams) lines.push("                params=params,");
+			lines.push(`                model=${responseModel},  # type: ignore[arg-type]  # dispatcher; request only calls from_dict`);
+			lines.push("                request_options=request_options,");
+			lines.push("            )");
+			lines.push("        )");
 		} else {
 			const returnPrefix = responseModel !== "None" ? "return " : "";
 			lines.push(`        ${returnPrefix}${awaitPrefix}self._client.request(`);
@@ -10808,6 +11402,9 @@ function generateResources$6(services, ctx) {
 			const plan = planOperation(op);
 			if (plan.responseModelName) {
 				if (!listWrapperNames.has(plan.responseModelName) || !plan.isPaginated) modelImports.add(plan.responseModelName);
+				if (!plan.isPaginated) {
+					if (ctx.spec.models.find((m) => m.name === plan.responseModelName)?.discriminator) modelImports.add(plan.responseModelName + "Variant");
+				}
 			}
 			if (op.requestBody?.kind === "model") {
 				const requestBodyRef = op.requestBody;
@@ -10867,10 +11464,15 @@ function generateResources$6(services, ctx) {
 			}
 		}
 		const localSet = new Set(localModels);
+		const variantToFile = /* @__PURE__ */ new Map();
+		for (const model of ctx.spec.models) if (model.discriminator) variantToFile.set(model.name + "Variant", fileName$2(model.name));
 		if (localModels.length > 0) lines.push(`from .models import ${localModels.map((n) => className$5(n)).join(", ")}`);
 		for (const [csDir, names] of [...crossServiceModels].sort()) {
 			const unique = names.filter((n) => !localSet.has(n));
-			for (const n of unique) lines.push(`from ${ctx.namespace}.${dirToModule(csDir)}.models.${fileName$2(n)} import ${className$5(n)}`);
+			for (const n of unique) {
+				const filePath = variantToFile.get(n) ?? fileName$2(n);
+				lines.push(`from ${ctx.namespace}.${dirToModule(csDir)}.models.${filePath} import ${className$5(n)}`);
+			}
 		}
 		const enumToServiceMap = placement.enumToService;
 		const localEnums = [];
@@ -11101,11 +11703,6 @@ const NON_SPEC_SERVICES = [
 		description: "Passwordless (magic-link) session endpoints, not yet in the OpenAPI spec.",
 		hasClientAccessor: true
 	},
-	{
-		id: "vault",
-		description: "Vault KV storage, key operations, and client-side AES-GCM encrypt/decrypt.",
-		hasClientAccessor: true
-	},
 	{
 		id: "webhook_verification",
 		description: "Webhook signature verification and event deserialization (H01/H02)."
@@ -11134,14 +11731,6 @@ const PYTHON_NON_SPEC_WIRING = {
 		ctorArg: "self",
 		docstring: "Passwordless authentication sessions."
 	},
-	vault: {
-		importLine: "from .vault import AsyncVault, Vault",
-		prop: "vault",
-		syncClass: "Vault",
-		asyncClass: "AsyncVault",
-		ctorArg: "self",
-		docstring: "Vault encryption, key management, and secret storage."
-	},
 	actions: {
 		importLine: "from .actions import Actions, AsyncActions",
 		prop: "actions",
@@ -11469,16 +12058,14 @@ function generateModelFixture$4(model, modelMap, enumMap) {
 	});
 	for (const field of deduplicatedFields) {
 		const wireName = field.name;
-		if (field.example !== void 0) fixture[wireName] = field.example;
+		if (field.example !== void 0) fixture[wireName] = normalizeDateTimeExample(field, field.example);
 		else fixture[wireName] = generateFieldValue$3(field.type, field.name, model.name, modelMap, enumMap);
 	}
 	if (model.discriminator) {
 		const [firstValue, variantName] = Object.entries(model.discriminator.mapping)[0];
 		fixture[model.discriminator.property] = firstValue;
 		const variantModel = modelMap.get(variantName);
-		if (variantModel) {
-			for (const field of variantModel.fields) if (!(field.name in fixture)) fixture[field.name] = field.example !== void 0 ? field.example : generateFieldValue$3(field.type, field.name, model.name, modelMap, enumMap);
-		}
+		if (variantModel) for (const field of variantModel.fields) fixture[field.name] = field.example !== void 0 ? normalizeDateTimeExample(field, field.example) : generateFieldValue$3(field.type, field.name, variantName, modelMap, enumMap);
 	}
 	return fixture;
 }
@@ -11505,6 +12092,20 @@ function generateFieldValue$3(ref, fieldName, modelName, modelMap, enumMap) {
 		case "map": return { key: generateFieldValue$3(ref.valueType, "value", modelName, modelMap, enumMap) };
 	}
 }
+/**
+* Normalize date-time example values to millisecond precision so that
+* round-trip tests (from_dict → to_dict) produce identical output.
+* Python's _format_datetime always serializes with milliseconds.
+*/
+function normalizeDateTimeExample(field, value) {
+	if (typeof value !== "string") return value;
+	const ref = field.type.kind === "nullable" ? field.type.inner : field.type;
+	if (ref?.kind !== "primitive" || ref?.type !== "string" || ref?.format !== "date-time") return value;
+	const match = value.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(\.\d+)?(Z|[+-]\d{2}:\d{2})$/);
+	if (!match) return value;
+	const [, prefix, , suffix] = match;
+	return `${prefix}.000${suffix}`;
+}
 function generatePrimitiveValue$3(type, format, name, modelName) {
 	switch (type) {
 		case "string":
@@ -11609,7 +12210,22 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 	const enumImports = /* @__PURE__ */ new Set();
 	for (const op of service.operations) {
 		const plan = planOperation(op);
-		if (plan.responseModelName) modelImports.add(plan.responseModelName);
+		if (plan.responseModelName) {
+			modelImports.add(plan.responseModelName);
+			if (!plan.isPaginated) {
+				const resolvedVariantClass = resolvePaginatedItemClass(plan.responseModelName, spec);
+				if (resolvedVariantClass && resolvedVariantClass !== className$5(plan.responseModelName)) {
+					const responseModel = spec.models.find((m) => m.name === plan.responseModelName);
+					const disc = responseModel && responseModel.discriminator;
+					if (disc) {
+						for (const variantName of Object.values(disc.mapping)) if (className$5(variantName) === resolvedVariantClass) {
+							modelImports.add(variantName);
+							break;
+						}
+					}
+				}
+			}
+		}
 		if (op.pagination?.itemType.kind === "model") {
 			modelImports.add(op.pagination.itemType.name);
 			let paginationItemName = op.pagination.itemType.name;
@@ -11652,10 +12268,12 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 			if (param.type.kind === "nullable" && param.type.inner.kind === "enum") enumImports.add(param.type.inner.name);
 		}
 	}
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
 	const actualImports = [...modelImports].filter((name) => {
 		const model = spec.models.find((m) => m.name === name);
 		if (!model) return true;
-		return !isListWrapperModel(model);
+		if (isListWrapperModel(model) && !nonPaginatedRefs.has(name)) return false;
+		return true;
 	});
 	const placement = computeSchemaPlacement(spec, ctx);
 	const modelToServiceMap = placement.modelToService;
@@ -11794,14 +12412,22 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 			const modelName = plan.responseModelName;
 			const fixtureName = `${fileName$2(modelName)}.json`;
 			const modelClass = className$5(modelName);
+			const resolvedClass = resolvePaginatedItemClass(modelName, spec) ?? modelClass;
+			const resolvedModelName = resolvedClass !== modelClass ? (() => {
+				const disc = spec.models.find((m) => m.name === modelName)?.discriminator;
+				if (disc) {
+					for (const variantName of Object.values(disc.mapping)) if (className$5(variantName) === resolvedClass) return variantName;
+				}
+				return modelName;
+			})() : modelName;
 			lines.push(`    def test_${method}(self, workos, httpx_mock):`);
 			lines.push(`        httpx_mock.add_response(`);
 			lines.push(`            json=load_fixture("${fixtureName}"),`);
 			lines.push("        )");
 			const args = buildTestArgs$1(op, spec, hiddenParams);
 			lines.push(`        result = workos.${propName}.${method}(${args})`);
-			lines.push(`        assert isinstance(result, ${modelClass})`);
-			const assertFields = pickAssertableFields(modelName, spec);
+			lines.push(`        assert isinstance(result, ${resolvedClass})`);
+			const assertFields = pickAssertableFields(resolvedModelName, spec);
 			for (const af of assertFields) {
 				const op_ = af.isBool ? "is" : "==";
 				lines.push(`        assert result.${af.field} ${op_} ${af.value}`);
@@ -12023,11 +12649,19 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 			const modelName = plan.responseModelName;
 			const fixtureName = `${fileName$2(modelName)}.json`;
 			const modelClass = className$5(modelName);
+			const asyncResolvedClass = resolvePaginatedItemClass(modelName, spec) ?? modelClass;
+			const asyncResolvedModelName = asyncResolvedClass !== modelClass ? (() => {
+				const disc = spec.models.find((m) => m.name === modelName)?.discriminator;
+				if (disc) {
+					for (const variantName of Object.values(disc.mapping)) if (className$5(variantName) === asyncResolvedClass) return variantName;
+				}
+				return modelName;
+			})() : modelName;
 			pushAsyncTestDef(lines, `    async def test_${method}(self, async_workos, httpx_mock):`);
 			lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
 			lines.push(`        result = await async_workos.${propName}.${method}(${asyncArgs})`);
-			lines.push(`        assert isinstance(result, ${modelClass})`);
-			const assertFields = pickAssertableFields(modelName, spec);
+			lines.push(`        assert isinstance(result, ${asyncResolvedClass})`);
+			const assertFields = pickAssertableFields(asyncResolvedModelName, spec);
 			for (const af of assertFields) {
 				const op_ = af.isBool ? "is" : "==";
 				lines.push(`        assert result.${af.field} ${op_} ${af.value}`);
@@ -12154,7 +12788,7 @@ function emitWrapperTests$1(lines, resolvedOps, propName, spec, ctx, isAsync) {
 		for (const wrapper of r.wrappers) {
 			const method = wrapper.name;
 			const wrapperParams = resolveWrapperParams(wrapper, ctx);
-			const responseType = wrapper.responseModelName ? className$5(wrapper.responseModelName) : null;
+			const resolvedResponseClass = wrapper.responseModelName ? resolvePaginatedItemClass(wrapper.responseModelName, spec) ?? className$5(wrapper.responseModelName) : null;
 			const fixtureName = wrapper.responseModelName ? `${fileName$2(wrapper.responseModelName)}.json` : null;
 			const argParts = [];
 			for (const { paramName, field, isOptional } of wrapperParams) {
@@ -12170,7 +12804,7 @@ function emitWrapperTests$1(lines, resolvedOps, propName, spec, ctx, isAsync) {
 				if (fixtureName) {
 					lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
 					lines.push(`        result = await async_workos.${propName}.${method}(${args})`);
-					if (responseType) lines.push(`        assert isinstance(result, ${responseType})`);
+					if (resolvedResponseClass) lines.push(`        assert isinstance(result, ${resolvedResponseClass})`);
 				} else {
 					lines.push("        httpx_mock.add_response(json={})");
 					lines.push(`        await async_workos.${propName}.${method}(${args})`);
@@ -12180,7 +12814,7 @@ function emitWrapperTests$1(lines, resolvedOps, propName, spec, ctx, isAsync) {
 				if (fixtureName) {
 					lines.push(`        httpx_mock.add_response(json=load_fixture("${fixtureName}"))`);
 					lines.push(`        result = workos.${propName}.${method}(${args})`);
-					if (responseType) lines.push(`        assert isinstance(result, ${responseType})`);
+					if (resolvedResponseClass) lines.push(`        assert isinstance(result, ${resolvedResponseClass})`);
 				} else {
 					lines.push("        httpx_mock.add_response(json={})");
 					lines.push(`        workos.${propName}.${method}(${args})`);
@@ -12950,8 +13584,9 @@ function generateModels$5(models, ctx) {
 		overwriteExisting: true
 	});
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
 	for (const model of models) {
-		if (isListMetadataModel(model)) continue;
+		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 		const name = className$4(model.name);
 		const lines = [];
@@ -13484,7 +14119,8 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 	const method = resolveMethodName$4(op, service, ctx);
 	const hiddenParams = new Set([...Object.keys(getOpDefaults(resolvedOp)), ...getOpInferFromClient(resolvedOp)]);
 	const isRedirect = isRedirectEndpoint(op, resolvedOp);
-	const params = buildMethodParams(op, plan, modelMap, ctx, hiddenParams);
+	const materializeQueryDefaults = !isRedirect;
+	const params = buildMethodParams(op, plan, modelMap, ctx, hiddenParams, { materializeQueryDefaults });
 	const returnType = isRedirect ? "string" : getReturnType(plan, ctx);
 	const docParts = [];
 	if (op.description) docParts.push(op.description);
@@ -13532,7 +14168,7 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 		const phpName = fieldName$4(q.name);
 		if (seenDocParams.has(phpName)) continue;
 		seenDocParams.add(phpName);
-		const hasEnumDefault = q.default != null && q.type.kind === "enum";
+		const hasEnumDefault = shouldMaterializeQueryDefault(q, materializeQueryDefaults);
 		const nullSuffix = !q.required && !hasEnumDefault && !docType.endsWith("|null") ? "|null" : "";
 		const prefix = q.deprecated ? "(deprecated) " : "";
 		let desc = q.description ? ` ${prefix}${q.description}` : q.deprecated ? " (deprecated)" : "";
@@ -13563,7 +14199,7 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 	const httpMethod = op.httpMethod.toUpperCase();
 	const path = buildPathString(op);
 	if (isRedirect) {
-		const queryLines = buildQueryArray(op, hiddenParams);
+		const queryLines = buildQueryArray(op, hiddenParams, { materializeQueryDefaults });
 		const hasDefaults = Object.keys(getOpDefaults(resolvedOp)).length > 0;
 		const hasInferred = getOpInferFromClient(resolvedOp).length > 0;
 		const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
@@ -13707,7 +14343,7 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 	}
 	lines.push("    }");
 }
-function buildMethodParams(op, plan, modelMap, ctx, hiddenParams) {
+function buildMethodParams(op, plan, modelMap, ctx, hiddenParams, opts) {
 	const required = [];
 	const optional = [];
 	const usedNames = /* @__PURE__ */ new Set();
@@ -13755,7 +14391,7 @@ function buildMethodParams(op, plan, modelMap, ctx, hiddenParams) {
 		if (usedNames.has(phpName)) continue;
 		usedNames.add(phpName);
 		if (q.required) required.push(`${phpType} $${phpName}`);
-		else if (q.default != null && q.type.kind === "enum") {
+		else if (shouldMaterializeQueryDefault(q, opts?.materializeQueryDefaults ?? true)) {
 			const enumType = mapTypeRef$5(q.type, { qualified: true });
 			const caseName = toPascalCase(String(q.default));
 			optional.push(`${enumType} $${phpName} = ${enumType}::${caseName}`);
@@ -13801,19 +14437,31 @@ function isEnumType(ref) {
 	if (ref.kind === "nullable") return isEnumType(ref.inner);
 	return false;
 }
-function buildQueryArray(op, hiddenParams) {
+function isDateTimeType(ref) {
+	if (ref.kind === "primitive" && ref.format === "date-time") return true;
+	if (ref.kind === "nullable") return isDateTimeType(ref.inner);
+	return false;
+}
+function buildQueryArray(op, hiddenParams, opts) {
 	const hidden = hiddenParams ?? /* @__PURE__ */ new Set();
 	const groupedParams = collectGroupedParamNames(op);
 	return op.queryParams.filter((q) => !hidden.has(q.name) && !groupedParams.has(q.name)).map((q) => {
 		const phpName = fieldName$4(q.name);
 		if (isEnumType(q.type)) {
-			const hasEnumDefault = q.default != null && q.type.kind === "enum";
+			const hasEnumDefault = shouldMaterializeQueryDefault(q, opts?.materializeQueryDefaults ?? true);
 			const nullsafe = q.required || hasEnumDefault ? "" : "?";
 			return `'${q.name}' => $${phpName}${nullsafe}->value,`;
 		}
+		if (isDateTimeType(q.type)) {
+			const nullsafe = q.required ? "" : "?";
+			return `'${q.name}' => $${phpName}${nullsafe}->format(\\DateTimeInterface::RFC3339_EXTENDED),`;
+		}
 		return `'${q.name}' => $${phpName},`;
 	});
 }
+function shouldMaterializeQueryDefault(param, enabled) {
+	return enabled && param.default != null && param.type.kind === "enum";
+}
 function phpLiteral(value) {
 	if (typeof value === "string") return `'${value}'`;
 	if (typeof value === "number") return String(value);
@@ -14005,8 +14653,10 @@ function generateFixtures$3(spec) {
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
 	const files = [];
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
 	for (const model of spec.models) {
-		if (isListMetadataModel(model)) continue;
+		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model)) continue;
 		const fixture = generateModelFixture$3(model, modelMap, enumMap);
 		files.push({
@@ -14351,13 +15001,15 @@ function buildTestArgs(op, ctx, opts) {
 }
 function generateTestValue(ref, ctx) {
 	switch (ref.kind) {
-		case "primitive": switch (ref.type) {
-			case "string": return "'test_value'";
-			case "integer": return "1";
-			case "number": return "1.0";
-			case "boolean": return "true";
-			default: return "'test_value'";
-		}
+		case "primitive":
+			if (ref.format === "date-time") return "new \\DateTimeImmutable('2023-01-01T00:00:00Z')";
+			switch (ref.type) {
+				case "string": return "'test_value'";
+				case "integer": return "1";
+				case "number": return "1.0";
+				case "boolean": return "true";
+				default: return "'test_value'";
+			}
 		case "enum":
 			if (ctx && ref.name) {
 				const e = ctx.spec.enums.find((en) => en.name === ref.name);
@@ -14444,7 +15096,8 @@ function emitQueryAssertions(lines, op, ctx, hidden) {
 		if (innerType.kind === "enum" && innerType.name) {
 			const e = ctx.spec.enums.find((en) => en.name === innerType.name);
 			if (e && e.values.length > 0) lines.push(`        $this->assertSame('${e.values[0].value}', $query['${q.name}']);`);
-		} else if (innerType.kind === "primitive") switch (innerType.type) {
+		} else if (innerType.kind === "primitive") if (innerType.format === "date-time") lines.push(`        $this->assertArrayHasKey('${q.name}', $query);`);
+		else switch (innerType.type) {
 			case "string":
 				lines.push(`        $this->assertSame('test_value', $query['${q.name}']);`);
 				break;
@@ -15154,6 +15807,8 @@ function generateEnums$4(enums, ctx) {
 		content: lines.join("\n"),
 		overwriteExisting: true
 	});
+	const eventConstantsFile = generateEventConstantsFile(enums);
+	if (eventConstantsFile) files.push(eventConstantsFile);
 	return files;
 }
 /** Known acronyms to preserve as single tokens during humanization. */
@@ -15214,6 +15869,56 @@ function collectEnumAliasOf$2(enums) {
 	}
 	return aliasOf;
 }
+function generateEventConstantsFile(enums) {
+	const enumDef = findWebhookEventEnum(enums);
+	if (!enumDef) return null;
+	const lines = [];
+	lines.push("package events");
+	lines.push("");
+	lines.push("// Event is a WorkOS event type.");
+	lines.push("type Event string");
+	lines.push("");
+	lines.push("const (");
+	const seenValues = /* @__PURE__ */ new Set();
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const value of enumDef.values) {
+		const valueStr = String(value.value);
+		if (seenValues.has(valueStr)) continue;
+		seenValues.add(valueStr);
+		const constName = uniqueEventConstantName(valueStr, usedNames);
+		usedNames.add(constName);
+		if (value.description) lines.push(`\t// ${constName} is ${value.description}.`);
+		if (value.deprecated) {
+			if (value.description) lines.push("	//");
+			lines.push("	// Deprecated: this value is deprecated.");
+		}
+		lines.push(`\t${constName} = "${escapeGoString$1(valueStr)}"`);
+	}
+	lines.push(")");
+	lines.push("");
+	return {
+		path: "pkg/events/events.go",
+		content: lines.join("\n"),
+		overwriteExisting: true
+	};
+}
+function findWebhookEventEnum(enums) {
+	return enums.find((enumDef) => enumDef.name === "CreateWebhookEndpointEvents") ?? enums.find((enumDef) => isWebhookEventEnumName(enumDef.name) && enumDef.values.length > 0 && enumDef.values.every((value) => typeof value.value === "string" && value.value.includes("."))) ?? null;
+}
+function isWebhookEventEnumName(name) {
+	const normalized = name.toLowerCase();
+	return normalized.includes("webhook") && normalized.includes("event");
+}
+function uniqueEventConstantName(value, usedNames) {
+	const base = className$3(value);
+	if (!usedNames.has(base)) return base;
+	let suffix = 2;
+	while (usedNames.has(`${base}${suffix}`)) suffix++;
+	return `${base}${suffix}`;
+}
+function escapeGoString$1(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
 //#endregion
 //#region src/go/wrappers.ts
 /**
@@ -16262,7 +16967,7 @@ function generateClient$4(spec, ctx) {
 	return [generateWorkOSFile(spec, ctx)];
 }
 /**
-* Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+* Non-spec services marked with `hasClientAccessor: true` (e.g. passwordless)
 * are included in the generated Client struct, constructor, and accessor methods
 * — identical to spec-driven services. Their service type (e.g. PasswordlessService)
 * is defined in a hand-written @oagen-ignore-file, but the Client wiring is generated.
@@ -20031,12 +20736,19 @@ function generateEnums$2(enums, _ctx) {
 		hashGroups.get(hash).push(enumDef);
 	}
 	const aliasOf = /* @__PURE__ */ new Map();
+	const sharedSortEmitters = /* @__PURE__ */ new Set();
 	for (const [, group] of hashGroups) {
-		if (group.length <= 1) continue;
+		if (group.length <= 1) {
+			if (group.length === 1 && isSharedSortOrderEnum(group[0])) {
+				enumCanonicalMap.set(group[0].name, "SortOrder");
+				sharedSortEmitters.add(group[0].name);
+			}
+			continue;
+		}
 		if (group.every(isSharedSortOrderEnum)) {
 			const [canonical, ...rest] = [...group].sort((a, b) => a.name.localeCompare(b.name));
-			enumCanonicalMap.set(canonical.name, canonical.name);
-			for (const enumDef of rest) enumCanonicalMap.set(enumDef.name, "SortOrder");
+			sharedSortEmitters.add(canonical.name);
+			for (const enumDef of [canonical, ...rest]) enumCanonicalMap.set(enumDef.name, "SortOrder");
 			continue;
 		}
 		const sorted = [...group].sort((a, b) => className$1(a.name).length - className$1(b.name).length || className$1(a.name).localeCompare(className$1(b.name)));
@@ -20050,7 +20762,7 @@ function generateEnums$2(enums, _ctx) {
 	for (const enumDef of enums) {
 		if (enumDef.values.length === 0) continue;
 		const typeName = canonicalEnumTypeName(enumDef);
-		const canonicalName = isSharedSortOrderEnum(enumDef) && enumCanonicalMap.get(enumDef.name) === enumDef.name ? void 0 : aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name);
+		const canonicalName = sharedSortEmitters.has(enumDef.name) ? void 0 : aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name);
 		if (canonicalName) {
 			const canonicalType = className$1(canonicalName);
 			if (typeName === canonicalType) continue;
@@ -24298,11 +25010,6 @@ const NON_SPEC_ACCESSORS = {
 		className: "Passwordless",
 		ctorArg: "self"
 	},
-	vault: {
-		prop: "vault",
-		className: "Vault",
-		ctorArg: "self"
-	},
 	actions: {
 		prop: "actions",
 		className: "Actions",
@@ -26119,6 +26826,7 @@ function classifyGroup(group, op) {
 function renderParamsStruct(name, op, resolved, registry, ctx, groupEmitter) {
 	const bodyRequired = isBodyRequired(op);
 	const hidden = new Set([...Object.keys(resolved.defaults ?? {}), ...resolved.inferFromClient ?? []]);
+	const materializeSpecDefaults = !resolved.urlBuilder;
 	const queryGroupParamNames = /* @__PURE__ */ new Set();
 	const bodyGroupParamNames = /* @__PURE__ */ new Set();
 	const queryGroupFields = [];
@@ -26155,7 +26863,7 @@ function renderParamsStruct(name, op, resolved, registry, ctx, groupEmitter) {
 		});
 		if (!p.required && !rust.startsWith("Option<")) rust = makeOptional(rust);
 		rust = applySecretRedaction(rust, p.name);
-		const defaultExpr = p.default != null ? rustDefaultExpr(p.default, p.type, rust.startsWith("Option<"), ctx) : null;
+		const defaultExpr = materializeSpecDefaults && p.default != null ? rustDefaultExpr(p.default, p.type, rust.startsWith("Option<"), ctx) : null;
 		const desc = p.description?.trim();
 		if (desc) for (const c of paramDocComment(desc)) fieldLines.push(`    ${c}`);
 		if (p.default != null) {
@@ -26788,7 +27496,7 @@ function renderResourcesBarrel(exports) {
 	}
 	unique.sort((a, b) => a.module.localeCompare(b.module));
 	const lines = [];
-	for (const { module } of unique) lines.push(`mod ${module};`);
+	for (const { module } of unique) lines.push(`pub mod ${module};`);
 	lines.push("");
 	for (const { module, struct } of unique) lines.push(`pub use ${module}::${struct};`);
 	return lines.join("\n") + "\n";
@@ -27650,4 +28358,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { pythonEmitter as _, rustExtractor as a, pythonExtractor as c, rustEmitter as d, rubyEmitter as f, phpEmitter as g, goEmitter as h, kotlinExtractor as i, rubyExtractor as l, dotnetEmitter as m, elixirExtractor as n, goExtractor as o, kotlinEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, nodeEmitter as v };
 
-//# sourceMappingURL=plugin-BGVaMGqe.mjs.map
+//# sourceMappingURL=plugin-CO4RFgAW.mjs.map