@workos/oagen-emitters 0.17.0 → 0.18.1

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.17.0"
+  ".": "0.18.1"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.18.1](https://github.com/workos/oagen-emitters/compare/v0.18.0...v0.18.1) (2026-06-17)
+
+
+### Bug Fixes
+
+* **node:** support owning services with hand-owned generic types ([#152](https://github.com/workos/oagen-emitters/issues/152)) ([aa8223d](https://github.com/workos/oagen-emitters/commit/aa8223dbb6b56f5c2ab12ac42e5a1fc9f9e99943))
+
+## [0.18.0](https://github.com/workos/oagen-emitters/compare/v0.17.0...v0.18.0) (2026-06-16)
+
+
+### Features
+
+* **node:** emit discriminated unions for pure oneOf token response ([#150](https://github.com/workos/oagen-emitters/issues/150)) ([1433bcc](https://github.com/workos/oagen-emitters/commit/1433bcc2f61db52aeadd7b947b79bb90c184c0a1))
+
 ## [0.17.0](https://github.com/workos/oagen-emitters/compare/v0.16.1...v0.17.0) (2026-06-15)
 
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as fieldName$4, B as servicePropertyName, C as apiClassName, D as dotnetEmitter, E as propertyName, F as fieldName$3, H as fieldName$1, I as methodName, L as trimMountedResourceFromMethod, M as trimMountedResourceFromMethod$1, N as goEmitter, O as appendAsyncSuffix, P as className, R as phpEmitter, S as kotlinEmitter, T as packageSegment, U as safeParamName$1, V as pythonEmitter, W as nodeEmitter, _ as rubyEmitter, a as rustExtractor, b as resolveServiceTarget, c as pythonExtractor, d as rustEmitter, f as fieldName$5, g as typeName, h as resourceAccessorName, i as kotlinExtractor, j as methodName$1, k as className$1, l as rubyExtractor, m as moduleName, n as elixirExtractor, o as goExtractor, p as methodName$3, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor, v as buildExportedClassNameSet, w as methodName$2, x as safeParamName, y as fieldName, z as fieldName$2 } from "./plugin-BLnR-FMi.mjs";
+import { A as fieldName$4, B as servicePropertyName, C as apiClassName, D as dotnetEmitter, E as propertyName, F as fieldName$3, H as fieldName$1, I as methodName, L as trimMountedResourceFromMethod, M as trimMountedResourceFromMethod$1, N as goEmitter, O as appendAsyncSuffix, P as className, R as phpEmitter, S as kotlinEmitter, T as packageSegment, U as safeParamName$1, V as pythonEmitter, W as nodeEmitter, _ as rubyEmitter, a as rustExtractor, b as resolveServiceTarget, c as pythonExtractor, d as rustEmitter, f as fieldName$5, g as typeName, h as resourceAccessorName, i as kotlinExtractor, j as methodName$1, k as className$1, l as rubyExtractor, m as moduleName, n as elixirExtractor, o as goExtractor, p as methodName$3, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor, v as buildExportedClassNameSet, w as methodName$2, x as safeParamName, y as fieldName, z as fieldName$2 } from "./plugin-CtU_wbid.mjs";
 import { collectSnippetArgs, collectWrapperArgs, toSnakeCase } from "@workos/oagen";
 //#region src/snippets/ruby.ts
 const INDENT$6 = "  ";

package/dist/{plugin-BLnR-FMi.mjs → plugin-CtU_wbid.mjs}

@@ -3626,6 +3626,17 @@ function isNodeOwnedService(ctx, ...names) {
 	const owned = new Set(configured.map(normalizeServiceName));
 	return names.some((name) => name !== void 0 ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false);
 }
+/**
+* True when `name` is a hand-owned type (see {@link NodeEmitterOptions.handOwnedTypes}).
+* Hand-owned types are never generated; the emitter defers to the existing
+* hand-written declaration and routes imports/barrel exports to it.
+*/
+function isHandOwnedType(ctx, name) {
+	if (name === void 0) return false;
+	const configured = nodeOptions(ctx).handOwnedTypes;
+	if (!configured || configured.length === 0) return false;
+	return configured.includes(name);
+}
 //#endregion
 //#region src/node/live-surface.ts
 const SRC_DIR = "src";
@@ -5582,9 +5593,15 @@ function optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, resol
 		generated: baselineTypeSourceFile(ctx, overrideType) === void 0
 	};
 	if (!operationHasOptionsInput(op, plan, resolvedOp)) return void 0;
+	const resolvedService = resolveResourceClassName$3(service, ctx);
+	let optionsType = methodOptionsName$1(method, resolvedService);
+	if (method !== "list") {
+		const baselineDir = baselineTypeSourceFile(ctx, optionsType)?.match(/^src\/([^/]+)\//)?.[1];
+		if (baselineDir && baselineDir !== resolveResourceDir(service, ctx)) optionsType = `${toPascalCase(resolvedService)}${toPascalCase(method)}Options`;
+	}
 	return {
 		name: "options",
-		type: methodOptionsName$1(method, resolveResourceClassName$3(service, ctx)),
+		type: optionsType,
 		optional: optionsObjectShouldBeOptional(op, plan, resolvedOp),
 		generated: true
 	};
@@ -5603,6 +5620,17 @@ function renderOptionsParam(param) {
 function isValidTypeIdentifier(name) {
 	return /^[A-Za-z_$][\w$]*$/.test(name);
 }
+/**
+* Extract candidate named type references from a compound type expression such
+* as `GetAccessTokenOptions & { provider: string }`. PascalCase tokens are type
+* names worth importing; lowercase tokens are property keys or primitives and
+* are skipped. The caller only imports the ones that resolve to a known source
+* file, so unrecognized PascalCase tokens (e.g. `Date`, `Record`) are harmless.
+*/
+function extractNamedTypeRefs(typeExpr) {
+	const matches = typeExpr.match(/\b[A-Z][A-Za-z0-9_$]*\b/g) ?? [];
+	return [...new Set(matches)];
+}
 function autoPaginatableItemType$1(returnType) {
 	return returnType?.match(/\b(?:AutoPaginatable|List)<\s*([A-Za-z_$][\w$]*)/)?.[1];
 }
@@ -5937,12 +5965,21 @@ function generateResourceClass(service, ctx) {
 	if (hasIdempotentPost || hasCustomEncoding) lines.push("import type { PostOptions } from '../common/interfaces/post-options.interface';");
 	const importedTypeNames = /* @__PURE__ */ new Set();
 	for (const optionType of optionObjectTypes) {
-		if (!isValidTypeIdentifier(optionType)) continue;
-		if (importedTypeNames.has(optionType)) continue;
-		importedTypeNames.add(optionType);
-		const sourceFile = baselineTypeSourceFile(ctx, optionType);
-		const relPath = sourceFile ? relativeImport(resourcePath, sourceFile) : `./interfaces/${fileName$3(optionType)}.interface`;
-		lines.push(`import type { ${optionType} } from '${relPath}';`);
+		if (isValidTypeIdentifier(optionType)) {
+			if (importedTypeNames.has(optionType)) continue;
+			importedTypeNames.add(optionType);
+			const sourceFile = baselineTypeSourceFile(ctx, optionType);
+			const relPath = sourceFile ? relativeImport(resourcePath, sourceFile) : `./interfaces/${fileName$3(optionType)}.interface`;
+			lines.push(`import type { ${optionType} } from '${relPath}';`);
+			continue;
+		}
+		for (const typeName of extractNamedTypeRefs(optionType)) {
+			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)}';`);
+		}
 	}
 	for (const typeName of returnTypeImports) {
 		if (importedTypeNames.has(typeName)) continue;
@@ -6059,7 +6096,7 @@ function generateResourceClass(service, ctx) {
 		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));
+			const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name) && !p.deprecated);
 			if (extraParams.length > 0) {
 				const optionsName = optionInfo?.type ?? paginatedOptionsName(method, resolvedName);
 				if (extraParams.some((p) => fieldName$6(p.name) !== wireFieldName(p.name))) {
@@ -7316,6 +7353,7 @@ function generateModels$7(models, ctx, shared) {
 		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 		if (discriminatedSkip?.has(model.name)) continue;
+		if (isHandOwnedType(ctx, model.name) || isHandOwnedType(ctx, resolveInterfaceName(model.name, ctx, { skipTypeAlias: true }))) continue;
 		const service = modelToService.get(model.name);
 		const isOwnedModel = isNodeOwnedService(ctx, service);
 		if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
@@ -7390,6 +7428,7 @@ function generateModels$7(models, ctx, shared) {
 		const crossServiceImports = /* @__PURE__ */ new Map();
 		const unresolvableNames = /* @__PURE__ */ new Set();
 		const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services, ctx.spec.models, ctx);
+		const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
 		const resolvedEnumNames = /* @__PURE__ */ new Map();
 		for (const e of ctx.spec.enums) resolvedEnumNames.set(resolveInterfaceName(e.name, ctx), e.name);
 		for (const field of model.fields) {
@@ -7409,7 +7448,7 @@ function generateModels$7(models, ctx, shared) {
 						const eDir = resolveDir(eService);
 						const bEnum = ctx.apiSurface?.enums?.[irEnumName];
 						const bAlias = ctx.apiSurface?.typeAliases?.[irEnumName];
-						const bSrc = isNodeOwnedService(ctx, eService) ? void 0 : bEnum?.sourceFile ?? bAlias?.sourceFile;
+						const bSrc = isNodeOwnedService(ctx, eService, eService ? serviceNameMap.get(eService) : void 0) ? void 0 : bEnum?.sourceFile ?? bAlias?.sourceFile;
 						const gPath = `src/${eDir}/interfaces/${fileName$3(irEnumName)}.interface.ts`;
 						const cPath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
 						if (bSrc === cPath) {
@@ -7454,7 +7493,7 @@ function generateModels$7(models, ctx, shared) {
 			const baselineEnum = ctx.apiSurface?.enums?.[dep];
 			const baselineAlias = ctx.apiSurface?.typeAliases?.[dep];
 			const depService = enumToService.get(dep);
-			const baselineSrc = isNodeOwnedService(ctx, depService) ? void 0 : baselineEnum?.sourceFile ?? baselineAlias?.sourceFile ?? liveSurfaceInterfacePath(dep);
+			const baselineSrc = isNodeOwnedService(ctx, depService, depService ? serviceNameMap.get(depService) : void 0) ? void 0 : baselineEnum?.sourceFile ?? baselineAlias?.sourceFile ?? liveSurfaceInterfacePath(dep);
 			const depDir = resolveDir(depService);
 			const generatedPath = `src/${depDir}/interfaces/${fileName$3(dep)}.interface.ts`;
 			const currentFilePath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
@@ -7677,6 +7716,7 @@ function generateSerializers(models, ctx, shared) {
 		if (isListMetadataModel(model) && !serializerListMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model) && !serializerNonPaginatedRefs.has(model.name)) continue;
 		if (discriminatedSerializerSkip?.has(model.name)) continue;
+		if (isHandOwnedType(ctx, model.name) || isHandOwnedType(ctx, resolveInterfaceName(model.name, ctx, { skipTypeAlias: true }))) continue;
 		if (!isNodeOwnedService(ctx, modelToService.get(model.name)) && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
 		eligibleModels.push(model);
 	}
@@ -7760,12 +7800,20 @@ function generateSerializers(models, ctx, shared) {
 	}
 	const liveRootForBarrel = ctx.outputDir ?? ctx.targetDir;
 	for (const [dir, stems] of serializersByDir) {
-		if (liveRootForBarrel && !isNodeOwnedService(ctx, dir)) {
+		if (liveRootForBarrel) {
+			const dirIsOwned = isNodeOwnedService(ctx, dir);
 			const serializersDir = path.join(liveRootForBarrel, "src", dir, "serializers");
 			try {
 				for (const entry of fs.readdirSync(serializersDir)) {
 					if (!entry.endsWith(".serializer.ts")) continue;
-					stems.add(entry.replace(/\.serializer\.ts$/, ""));
+					const stem = entry.replace(/\.serializer\.ts$/, "");
+					if (stems.has(stem)) continue;
+					if (dirIsOwned) {
+						const content = fs.readFileSync(path.join(serializersDir, entry), "utf-8");
+						if (/auto-generated by oagen/i.test(content.slice(0, 400))) continue;
+						if (![...content.matchAll(/export\s+(?:const|function)\s+((?:de)?serialize[A-Za-z0-9_]+)/g)].map((m) => m[1].replace(/^(?:de)?serialize/, "")).some((typeName) => isHandOwnedType(ctx, typeName))) continue;
+					}
+					stems.add(stem);
 				}
 			} catch {}
 		}
@@ -8049,12 +8097,12 @@ function exportedNamesForSource(ctx, sourceFile) {
 */
 function generateServiceBarrels(spec, ctx) {
 	const files = [];
-	const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+	const { modelToService, resolveDir, serviceNameMap } = createServiceDirResolver(spec.models, spec.services, 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)) {
+	for (const service of spec.services) if (isNodeOwnedService(ctx, service.name, serviceNameMap.get(service.name))) {
 		const dir = resolveDir(service.name);
 		ownedDirNames.add(dir);
 		if (!dirExports.has(dir)) {
@@ -8825,12 +8873,12 @@ function buildOptionsObjectTestArg(op, plan, baselineMethod, modelMap, ctx) {
 		entries.push(`${optionField}: ${JSON.stringify(pathParamTestValue(param, localName))}`);
 	}
 	if (plan.isPaginated) entries.push("order: 'desc'");
-	const queryParams = plan.isPaginated ? op.queryParams.filter((param) => ![
+	const queryParams = (plan.isPaginated ? op.queryParams.filter((param) => ![
 		"limit",
 		"before",
 		"after",
 		"order"
-	].includes(param.name)) : op.queryParams;
+	].includes(param.name)) : op.queryParams).filter((param) => !param.deprecated);
 	for (const param of queryParams) {
 		const localName = fieldName$6(param.name);
 		const value = queryParamTestValue(param, modelMap);
@@ -9374,10 +9422,11 @@ function dedupeLiteralTypes(types) {
 //#region src/node/discriminated-models.ts
 function detectDiscriminatedShape(modelName, rawSchemas) {
 	const schema = rawSchemas[modelName];
-	if (!schema?.allOf) return null;
+	if (!schema) return null;
 	let baseObject = null;
 	let oneOfVariants = null;
-	for (const member of schema.allOf) {
+	let inlineUnion = false;
+	if (schema.allOf) for (const member of schema.allOf) {
 		const resolved = resolveRef(member, rawSchemas);
 		if (resolved.oneOf) {
 			if (oneOfVariants) return null;
@@ -9388,16 +9437,22 @@ function detectDiscriminatedShape(modelName, rawSchemas) {
 			baseObject = mergeBase(baseObject, nestedBase);
 		}
 	}
+	else if (schema.oneOf && schema.oneOf.length >= 2) {
+		if (!schema.oneOf.every((v) => v.properties && !v.$ref && (v.type === "object" || !v.type) && !v.allOf && !v.oneOf)) return null;
+		oneOfVariants = schema.oneOf;
+		inlineUnion = true;
+	} else return null;
 	if (!oneOfVariants || oneOfVariants.length < 2) return null;
 	const flattenedVariants = oneOfVariants.map((v) => flattenVariant(v, rawSchemas));
 	const discProp = findSharedDiscriminator(flattenedVariants);
 	if (!discProp) return null;
 	const variants = flattenedVariants.map((fv) => {
-		const discValue = readConstString(fv.alwaysProperties.get(discProp));
-		if (!discValue) return null;
+		const discValue = readConst(fv.alwaysProperties.get(discProp));
+		if (discValue === null) return null;
 		return {
-			nameSuffix: variantNameSuffix(discValue),
-			discriminatorValue: discValue,
+			nameSuffix: variantNameSuffix(String(discValue)),
+			discriminatorValue: String(discValue),
+			discriminatorIsBoolean: typeof discValue === "boolean",
 			fields: variantFields(fv, discProp, modelName)
 		};
 	}).filter((v) => v !== null);
@@ -9410,7 +9465,8 @@ function detectDiscriminatedShape(modelName, rawSchemas) {
 		discriminatorProperty: discProp,
 		discriminatorPropertyDomain: toCamelCase(discProp),
 		discriminatorDescription,
-		variants
+		variants,
+		inlineUnion
 	};
 }
 function mergeBase(prev, next) {
@@ -9525,21 +9581,29 @@ function findSharedDiscriminator(variants) {
 		let allConst = true;
 		const values = [];
 		for (const v of variants) {
-			const val = readConstString(v.alwaysProperties.get(propName));
+			const val = readConst(v.alwaysProperties.get(propName));
 			if (val === null) {
 				allConst = false;
 				break;
 			}
-			values.push(val);
+			values.push(String(val));
 		}
 		if (allConst && new Set(values).size === values.length) return propName;
 	}
 	return null;
 }
-function readConstString(schema) {
+/**
+* Read a discriminator value pinned by `const` (or a single-value `enum`).
+* Supports string and boolean literals — the latter drives the
+* `active: true | false` style token response union.
+*/
+function readConst(schema) {
 	if (!schema) return null;
-	if (typeof schema.const === "string") return schema.const;
-	if (Array.isArray(schema.enum) && schema.enum.length === 1 && typeof schema.enum[0] === "string") return schema.enum[0];
+	if (typeof schema.const === "string" || typeof schema.const === "boolean") return schema.const;
+	if (Array.isArray(schema.enum) && schema.enum.length === 1) {
+		const only = schema.enum[0];
+		if (typeof only === "string" || typeof only === "boolean") return only;
+	}
 	return null;
 }
 function variantNameSuffix(constValue) {
@@ -9568,6 +9632,7 @@ function buildField(rawName, schema, required, parentName) {
 	const modelDeps = /* @__PURE__ */ new Set();
 	const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps);
 	const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps);
+	const enumValues = Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((e) => typeof e === "string") ? schema.enum : void 0;
 	return {
 		name: rawName,
 		description: schema.description,
@@ -9575,7 +9640,8 @@ function buildField(rawName, schema, required, parentName) {
 		domainType,
 		wireType,
 		modelDeps,
-		hasDateTime: schemaHasDateTime(schema)
+		hasDateTime: schemaHasDateTime(schema),
+		enumValues
 	};
 }
 function schemaHasDateTime(schema) {
@@ -9644,13 +9710,15 @@ function planDiscriminatedModels(models, ctx) {
 		const stripped = rawName.replace(/Dto/g, "").replace(/DTO/g, "").replace(/Json$/, "");
 		if (stripped !== rawName && irModelDir.has(stripped)) depDirMap.set(rawName, irModelDir.get(stripped));
 	}
+	for (const [irName, dir] of irModelDir) if (!depDirMap.has(irName)) depDirMap.set(irName, dir);
 	for (const model of models) {
 		const shape = detectDiscriminatedShape(model.name, rawSchemas);
 		if (!shape) continue;
 		const allDeps = /* @__PURE__ */ new Set();
 		for (const field of shape.baseFields) for (const d of field.modelDeps) allDeps.add(d);
 		for (const variant of shape.variants) for (const field of variant.fields) for (const d of field.modelDeps) allDeps.add(d);
-		if ([...allDeps].some((dep) => !depDirMap.has(dep) && !irModelDir.has(dep))) continue;
+		const resolvable = (dep) => depDirMap.has(dep) || irModelDir.has(dep) || depDirMap.has(toPascalCase(dep)) || irModelDir.has(toPascalCase(dep));
+		if ([...allDeps].some((dep) => !resolvable(dep))) continue;
 		const modelDir = resolveDir(modelToService.get(model.name));
 		plans.set(model.name, {
 			shape,
@@ -9670,6 +9738,7 @@ function generateDiscriminatedFiles(plans, ctx) {
 }
 function buildInterfaceFile(plan, _ctx) {
 	const { shape, modelDir } = plan;
+	if (shape.inlineUnion) return buildInlineUnionFile(plan);
 	const domain = toPascalCase(shape.modelName);
 	const wire = wireInterfaceName(domain);
 	const lines = [];
@@ -9697,6 +9766,45 @@ function buildInterfaceFile(plan, _ctx) {
 		overwriteExisting: true
 	};
 }
+/**
+* Emit a pure-`oneOf` discriminated union as a single inline type alias
+* (`export type X = { … } | { … }`) for both the domain and wire shapes. Used
+* instead of named per-variant interfaces, which read poorly for small
+* (often two-variant, boolean-discriminated) unions like the token response.
+*/
+function buildInlineUnionFile(plan) {
+	const { shape, modelDir } = plan;
+	const domain = toPascalCase(shape.modelName);
+	const wire = wireInterfaceName(domain);
+	const lines = [];
+	const imports = collectImports$2(plan);
+	if (imports.length > 0) {
+		for (const imp of imports) lines.push(`import type { ${imp.symbols.join(", ")} } from '${imp.path}';`);
+		lines.push("");
+	}
+	lines.push(...buildInlineUnionAlias(domain, shape, false));
+	lines.push("");
+	lines.push(...buildInlineUnionAlias(wire, shape, true));
+	return {
+		path: `src/${modelDir}/interfaces/${fileName$3(shape.modelName)}.interface.ts`,
+		content: lines.join("\n") + "\n",
+		overwriteExisting: true
+	};
+}
+function buildInlineUnionAlias(name, shape, isWire) {
+	const lines = [`export type ${name} =`];
+	shape.variants.forEach((variant, idx) => {
+		const isLast = idx === shape.variants.length - 1;
+		const members = [`${isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain}: ${discLiteral(variant)}`];
+		for (const field of variant.fields) {
+			const key = isWire ? field.name : toCamelCase(field.name);
+			const opt = field.required ? "" : "?";
+			members.push(`${key}${opt}: ${inlineFieldType(field, isWire)}`);
+		}
+		lines.push(`  | { ${members.join("; ")} }${isLast ? ";" : ""}`);
+	});
+	return lines;
+}
 function buildInterfaceBody(name, shape, variant, isWire) {
 	const lines = [];
 	lines.push(`export interface ${name} {`);
@@ -9708,11 +9816,32 @@ function buildInterfaceBody(name, shape, variant, isWire) {
 	}
 	const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
 	if (shape.discriminatorDescription) lines.push(`  /** ${shape.discriminatorDescription} */`);
-	lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
+	lines.push(`  ${discKey}: ${discLiteral(variant)};`);
 	for (const field of variant.fields) pushFieldLine(lines, field, isWire);
 	lines.push("}");
 	return lines;
 }
+/**
+* The discriminator value as a TS literal: quoted for strings (`'oauth'`),
+* bare for booleans (`true`).
+*/
+function discLiteral(variant) {
+	return variant.discriminatorIsBoolean ? variant.discriminatorValue : `'${variant.discriminatorValue}'`;
+}
+/**
+* Field type for an inline-union member: a literal union for inline string
+* enums, otherwise the resolved domain/wire type.
+*
+* The `enumValues` branch deliberately ignores `isWire`: `enumValues` is only
+* populated for string enums (see `buildField`), whose domain and wire
+* representations are identical literal unions. Any field whose domain/wire
+* types actually differ (model refs, dates, non-string enums) leaves
+* `enumValues` undefined and falls through to the type-specific branch.
+*/
+function inlineFieldType(field, isWire) {
+	if (field.enumValues) return field.enumValues.map((v) => `'${v}'`).join(" | ");
+	return isWire ? field.wireType : field.domainType;
+}
 function pushFieldLine(lines, field, isWire) {
 	const key = isWire ? field.name : toCamelCase(field.name);
 	const opt = field.required ? "" : "?";
@@ -9729,7 +9858,7 @@ function collectImports$2(plan) {
 		const domain = toPascalCase(dep);
 		const wire = wireInterfaceName(domain);
 		const symbols = wire !== domain ? [domain, wire] : [domain];
-		const depDir = plan.depDirMap.get(dep);
+		const depDir = plan.depDirMap.get(dep) ?? plan.depDirMap.get(domain);
 		const baseName = fileName$3(toSnakeFromPascal(domain));
 		let importPath;
 		if (!depDir || depDir === plan.modelDir) importPath = `./${baseName}.interface`;
@@ -9756,39 +9885,43 @@ function buildSerializerFile(plan, _ctx) {
 	const allDeps = /* @__PURE__ */ new Set();
 	for (const field of shape.baseFields) for (const d of field.modelDeps) allDeps.add(d);
 	for (const variant of shape.variants) for (const field of variant.fields) for (const d of field.modelDeps) allDeps.add(d);
+	const deserializeOnly = shape.inlineUnion === true;
 	for (const dep of [...allDeps].sort()) {
 		const depDomain = toPascalCase(dep);
 		const depFile = fileName$3(toSnakeFromPascal(depDomain));
-		lines.push(`import { deserialize${depDomain}, serialize${depDomain} } from './${depFile}.serializer';`);
+		const helpers = deserializeOnly ? `deserialize${depDomain}` : `deserialize${depDomain}, serialize${depDomain}`;
+		lines.push(`import { ${helpers} } from './${depFile}.serializer';`);
 	}
 	lines.push("");
 	lines.push(`export const deserialize${domain} = (response: ${wire}): ${domain} => {`);
 	lines.push(`  switch (response.${shape.discriminatorProperty}) {`);
 	for (const variant of shape.variants) {
-		lines.push(`    case '${variant.discriminatorValue}':`);
+		lines.push(`    case ${discLiteral(variant)}:`);
 		lines.push(`      return {`);
 		for (const field of shape.baseFields) lines.push(`        ${assignmentLine(field, false, allDeps)},`);
-		lines.push(`        ${shape.discriminatorPropertyDomain}: '${variant.discriminatorValue}',`);
+		lines.push(`        ${shape.discriminatorPropertyDomain}: ${discLiteral(variant)},`);
 		for (const field of variant.fields) lines.push(`        ${assignmentLine(field, false, allDeps)},`);
 		lines.push(`      };`);
 	}
 	lines.push(`    default:`);
-	lines.push(`      throw new Error(\`Unknown ${shape.discriminatorProperty}: \${(response as { ${shape.discriminatorProperty}: string }).${shape.discriminatorProperty}}\`);`);
+	lines.push(`      throw new Error(\`Unknown ${shape.discriminatorProperty}: \${String((response as Record<string, unknown>).${shape.discriminatorProperty})}\`);`);
 	lines.push(`  }`);
 	lines.push(`};`);
-	lines.push("");
-	lines.push(`export const serialize${domain} = (model: ${domain}): ${wire} => {`);
-	lines.push(`  switch (model.${shape.discriminatorPropertyDomain}) {`);
-	for (const variant of shape.variants) {
-		lines.push(`    case '${variant.discriminatorValue}':`);
-		lines.push(`      return {`);
-		for (const field of shape.baseFields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
-		lines.push(`        ${shape.discriminatorProperty}: '${variant.discriminatorValue}',`);
-		for (const field of variant.fields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
-		lines.push(`      };`);
+	if (!deserializeOnly) {
+		lines.push("");
+		lines.push(`export const serialize${domain} = (model: ${domain}): ${wire} => {`);
+		lines.push(`  switch (model.${shape.discriminatorPropertyDomain}) {`);
+		for (const variant of shape.variants) {
+			lines.push(`    case ${discLiteral(variant)}:`);
+			lines.push(`      return {`);
+			for (const field of shape.baseFields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
+			lines.push(`        ${shape.discriminatorProperty}: ${discLiteral(variant)},`);
+			for (const field of variant.fields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
+			lines.push(`      };`);
+		}
+		lines.push(`  }`);
+		lines.push(`};`);
 	}
-	lines.push(`  }`);
-	lines.push(`};`);
 	return {
 		path: `src/${modelDir}/serializers/${fileName$3(shape.modelName)}.serializer.ts`,
 		content: lines.join("\n") + "\n",
@@ -29764,4 +29897,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { fieldName$2 as A, servicePropertyName$2 as B, apiClassName as C, dotnetEmitter as D, propertyName as E, fieldName$3 as F, fieldName$5 as H, methodName$3 as I, trimMountedResourceFromMethod$2 as L, trimMountedResourceFromMethod$1 as M, goEmitter as N, appendAsyncSuffix as O, className$3 as P, phpEmitter as R, kotlinEmitter as S, packageSegment as T, safeParamName$1 as U, pythonEmitter as V, nodeEmitter as W, rubyEmitter as _, rustExtractor as a, resolveServiceTarget as b, pythonExtractor as c, rustEmitter as d, fieldName as f, typeName as g, resourceAccessorName as h, kotlinExtractor as i, methodName$2 as j, className$2 as k, rubyExtractor as l, moduleName as m, elixirExtractor as n, goExtractor as o, methodName as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, buildExportedClassNameSet as v, methodName$1 as w, safeParamName as x, fieldName$1 as y, fieldName$4 as z };
 
-//# sourceMappingURL=plugin-BLnR-FMi.mjs.map
+//# sourceMappingURL=plugin-CtU_wbid.mjs.map