@workos/oagen-emitters 0.8.1 → 0.9.0

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

@@ -17397,9 +17397,29 @@ function findDotnetWorkspace(targetDir) {
 }
 //#endregion
 //#region src/kotlin/naming.ts
+/**
+* Acronyms that should appear fully uppercase in PascalCase identifiers.
+* `toPascalCase` would otherwise titlecase them (e.g. `Sso`, `Pkce`, `Mfa`).
+* Both [className] and [apiClassName] consult this list so model and service
+* class names stay consistent (e.g. `SsoConnection` -> `SSOConnection`).
+*/
+const PASCAL_ACRONYMS = [
+	"SSO",
+	"PKCE",
+	"MFA"
+];
+function uppercaseAcronyms(pascal) {
+	let result = pascal;
+	for (const acronym of PASCAL_ACRONYMS) {
+		const titled = acronym.charAt(0) + acronym.slice(1).toLowerCase();
+		const re = new RegExp(`${titled}(?=[A-Z0-9]|$)`, "g");
+		result = result.replace(re, acronym);
+	}
+	return result;
+}
 /** PascalCase class/type name. */
 function className$1(name) {
-	return toPascalCase(stripUrnPrefix(name));
+	return uppercaseAcronyms(toPascalCase(stripUrnPrefix(name)));
 }
 /** camelCase method name. */
 function methodName(name) {
@@ -17417,7 +17437,6 @@ function packageSegment(name) {
 }
 /** Kotlin service class name for a mount group (e.g., `Organizations`). */
 function apiClassName(name) {
-	if (className$1(name) === "SSO") return "Sso";
 	return className$1(name);
 }
 /** Accessor property exposed on the WorkOS client (camelCase). */
@@ -17528,6 +17547,33 @@ function clientFieldExpression(field) {
 function humanize(name) {
 	return name.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
 }
+/**
+* If the parameter is typed as an enum and its description is long enough
+* that repeating it across every method's KDoc adds noise, return a short
+* description that defers to the enum's own KDoc with a `See [EnumName].`
+* reference. Otherwise return null and the caller keeps the spec text.
+*
+* Currently only `PaginationOrder` is shortened — the SSO/MFA/etc. enums
+* have brief descriptions already. Generalize when other long-description
+* enums appear in the spec.
+*/
+const LONG_ENUM_DESC_THRESHOLD = 120;
+function maybeShortenEnumParamDescription(type, description) {
+	if (!type || !description) return null;
+	const enumName = extractEnumName(type);
+	if (!enumName) return null;
+	if (description.length <= LONG_ENUM_DESC_THRESHOLD) return null;
+	if (className$1(enumName) !== "PaginationOrder") return null;
+	return {
+		description: `the order to return records in. See [${className$1(enumName)}].`,
+		enumRef: className$1(enumName)
+	};
+}
+function extractEnumName(type) {
+	if (type.kind === "enum") return type.name;
+	if (type.kind === "nullable") return extractEnumName(type.inner);
+	return null;
+}
 //#endregion
 //#region src/kotlin/enums.ts
 const KOTLIN_SRC_PREFIX$3 = "src/main/kotlin/";
@@ -17632,15 +17678,20 @@ function generateEnums$1(enums, _ctx) {
 			if (v.deprecated) members.push("  @Deprecated(\"Deprecated enum value\")");
 			members.push(`  ${memberName}(${ktStringLiteral(wire)})`);
 		}
+		let firstValueEmitted = false;
 		for (let i = 0; i < members.length; i++) {
 			const isLast = i === members.length - 1;
 			const line = members[i];
 			const trimmedStart = line.trimStart();
-			if (trimmedStart.startsWith("/**") || trimmedStart.startsWith("@")) {
+			const isDocStart = trimmedStart.startsWith("/**");
+			const isAnnotation = trimmedStart.startsWith("@");
+			if (isDocStart && firstValueEmitted) lines.push("");
+			if (isDocStart || isAnnotation) {
 				lines.push(line);
 				continue;
 			}
 			lines.push(isLast ? line : `${line},`);
+			firstValueEmitted = true;
 		}
 		lines.push("}");
 		lines.push("");
@@ -17749,6 +17800,40 @@ const KOTLIN_SRC_PREFIX$2 = "src/main/kotlin/";
 const MODELS_PACKAGE = "com.workos.models";
 const MODELS_DIR = "com/workos/models";
 /**
+* Some specs leave string fields without `format: date-time` even though the
+* description (or the example) makes clear they carry an ISO-8601 timestamp.
+* Detect that here so we can promote the type to `OffsetDateTime` in the
+* Kotlin output.
+*/
+const ISO_8601_DESCRIPTION_RE$2 = /\bISO[-_ ]?8601\b/i;
+function looksLikeIso8601String$2(description) {
+	if (!description) return false;
+	return ISO_8601_DESCRIPTION_RE$2.test(description);
+}
+function promoteIso8601TypeRef$2(type, description) {
+	if (!looksLikeIso8601String$2(description)) return type;
+	const promote = (t) => {
+		if (t.kind === "primitive" && t.type === "string" && !t.format) return {
+			kind: "primitive",
+			type: "string",
+			format: "date-time"
+		};
+		if (t.kind === "nullable") return {
+			kind: "nullable",
+			inner: promote(t.inner)
+		};
+		return t;
+	};
+	return promote(type);
+}
+function promoteFieldType$1(f) {
+	const promoted = promoteIso8601TypeRef$2(f.type, f.description);
+	return promoted === f.type ? f : {
+		...f,
+		type: promoted
+	};
+}
+/**
 * Generate Kotlin `data class` models. Each model becomes a separate `.kt`
 * file under `com.workos.models`. Discriminated unions emit a sealed class
 * with Jackson `@JsonTypeInfo` / `@JsonSubTypes` annotations so the base type
@@ -17878,6 +17963,7 @@ function emitDataClass(model) {
 		for (let i = 0; i < rendered.length; i++) {
 			const suffix = i === rendered.length - 1 ? "" : ",";
 			lines.push(`${rendered[i]}${suffix}`);
+			if (i < rendered.length - 1) lines.push("");
 		}
 		lines.push(`)${implClause}`);
 		lines.push("");
@@ -17895,7 +17981,29 @@ function emitSealedUnion(typeName, disc) {
 	lines.push("import com.fasterxml.jackson.annotation.JsonSubTypes");
 	lines.push("import com.fasterxml.jackson.annotation.JsonTypeInfo");
 	lines.push("");
-	appendKdoc(lines, `Discriminated union over ${typeName} variants. Selected by \`${disc.property}\`.`, 0);
+	const exampleVariantWire = Object.keys(disc.mapping)[0];
+	const exampleVariantType = exampleVariantWire ? className$1(disc.mapping[exampleVariantWire]) : null;
+	lines.push("/**");
+	lines.push(` * Discriminated union over ${typeName} variants. Selected by \`${disc.property}\`.`);
+	if (exampleVariantType) {
+		lines.push(" *");
+		lines.push(" * Usage from Kotlin:");
+		lines.push(" * ```kotlin");
+		lines.push(` * when (val v: ${typeName} = receivedFromApi()) {`);
+		lines.push(` *   is ${exampleVariantType} -> handle(v)`);
+		lines.push(" *   else -> handleOther(v)");
+		lines.push(" * }");
+		lines.push(" * ```");
+		lines.push(" *");
+		lines.push(" * Usage from Java:");
+		lines.push(" * ```java");
+		lines.push(` * ${typeName} v = receivedFromApi();`);
+		lines.push(` * if (v instanceof ${exampleVariantType}) {`);
+		lines.push(` *     handle((${exampleVariantType}) v);`);
+		lines.push(" * }");
+		lines.push(" * ```");
+	}
+	lines.push(" */");
 	lines.push("@JsonTypeInfo(");
 	lines.push("  use = JsonTypeInfo.Id.NAME,");
 	lines.push("  include = JsonTypeInfo.As.EXISTING_PROPERTY,");
@@ -17985,7 +18093,8 @@ function emitWorkOSEvent(eventMapping) {
 function renderFields(fields, overrideFields = /* @__PURE__ */ new Set()) {
 	const seen = /* @__PURE__ */ new Set();
 	const lines = [];
-	for (const field of fields) {
+	for (const rawField of fields) {
+		const field = promoteFieldType$1(rawField);
 		const kotlinName = propertyName(field.name);
 		if (seen.has(kotlinName)) continue;
 		seen.add(kotlinName);
@@ -18004,7 +18113,7 @@ function renderFields(fields, overrideFields = /* @__PURE__ */ new Set()) {
 		const isOverride = overrideFields.has(kotlinName);
 		const annotations = [];
 		annotations.push(`@JsonProperty(${ktStringLiteral(field.name)})`);
-		if (field.deprecated) annotations.push("@Deprecated(\"Deprecated field\")");
+		if (field.deprecated) annotations.push(buildDeprecatedAnnotation(field.description));
 		const paramParts = [];
 		if (field.description?.trim()) {
 			const line = field.description.split("\n").find((l) => l.trim()) ?? "";
@@ -18035,6 +18144,26 @@ function collapseFieldEntries(rawLines) {
 	return entries;
 }
 /**
+* Pull the most useful free-form deprecation hint out of a field description
+* and lift it into the `@Deprecated(...)` message argument. Most WorkOS
+* deprecations are written as a description that begins with "Deprecated"
+* (e.g. "Deprecated. Use `domain_data` instead."). When the description
+* doesn't carry a hint we fall back to a short, self-explanatory message
+* rather than the generic "Deprecated field" placeholder.
+*/
+function deprecationMessageFromDescription(description) {
+	if (!description) return "Deprecated.";
+	const firstLine = description.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+	if (!firstLine) return "Deprecated.";
+	const collapsed = firstLine.replace(/\s+/g, " ").trim();
+	if (collapsed.length === 0) return "Deprecated.";
+	if (/\bdeprecat/i.test(collapsed)) return collapsed;
+	return "Deprecated.";
+}
+function buildDeprecatedAnnotation(description) {
+	return `@Deprecated(${ktStringLiteral(deprecationMessageFromDescription(description))})`;
+}
+/**
 * If the TypeRef is a literal (const) with a string, number, or boolean value,
 * return the Kotlin expression for that default. Otherwise return null.
 */
@@ -18049,7 +18178,8 @@ function collectImports(fields) {
 	const imports = /* @__PURE__ */ new Set();
 	if (fields.length === 0) return imports;
 	imports.add("com.fasterxml.jackson.annotation.JsonProperty");
-	for (const field of fields) {
+	for (const rawField of fields) {
+		const field = promoteFieldType$1(rawField);
 		const mapped = mapTypeRef$1(field.type);
 		if (/\bOffsetDateTime\b/.test(mapped)) imports.add("java.time.OffsetDateTime");
 		for (const enumName of collectEnumNames(field.type)) {
@@ -18174,6 +18304,81 @@ function escapeKotlinStringLiteral(literal) {
 	return literal.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$");
 }
 //#endregion
+//#region src/kotlin/suspend.ts
+/**
+* Helpers for emitting `suspend` overloads alongside every generated
+* blocking SDK method. The suspend variant simply delegates to the blocking
+* implementation under `withContext(Dispatchers.IO)`, so callers can invoke
+* any operation from a coroutine context without blocking the calling
+* dispatcher.
+*
+* Naming: the suspend variant uses a `Suspend`-suffixed Kotlin source name
+* (e.g. `deleteEndpointSuspend`). This matters because Kotlin does not let
+* a `suspend` function and a non-`suspend` function with the same name and
+* identical value parameters coexist in the same scope — they are not
+* distinguishable at call sites, even with `@JvmName`. (`@JvmName` only
+* disambiguates JVM signatures, not Kotlin source names.) Naming the suspend
+* variant explicitly sidesteps the conflict and makes the choice between
+* blocking and suspending callable obvious at the call site. The matching
+* `@JvmName("...Suspend")` is now technically redundant but kept for
+* explicit clarity in Java interop / tooling.
+*/
+/**
+* Emit a suspend overload that delegates to a blocking method.
+*
+* The emitted lines preserve the parameter declarations (including default
+* values) so callers can invoke the suspend variant with named arguments and
+* skip optional parameters, just as they do with the blocking version.
+*
+* The emitted suspend method is named `${methodName}Suspend` (a distinct
+* Kotlin source name from the blocking method) — see the file-level KDoc for
+* why this is required.
+*/
+function emitSuspendVariant(opts) {
+	const { methodName, params, returnType, deprecated } = opts;
+	const suspendName = `${methodName}Suspend`;
+	const lines = [];
+	lines.push("  /**");
+	lines.push(`   * Coroutine-aware variant of [${escapeReserved(methodName)}]. Use this from`);
+	lines.push("   * a `suspend` function or coroutine scope.");
+	lines.push("   *");
+	lines.push(`   * Delegates to the blocking [${escapeReserved(methodName)}] under`);
+	lines.push("   * `withContext(Dispatchers.IO)`, so this is safe to call from any");
+	lines.push("   * coroutine dispatcher (including `Dispatchers.Main`).");
+	lines.push("   */");
+	if (deprecated) lines.push("  @Deprecated(\"Deprecated operation\")");
+	lines.push(`  @JvmName(${jvmNameLiteral(suspendName)})`);
+	const returnClause = returnType === "Unit" ? "" : `: ${returnType}`;
+	const callArgs = params.map((p) => p.name).join(", ");
+	if (params.length === 0) {
+		lines.push(`  suspend fun ${escapeReserved(suspendName)}()${returnClause} = withContext(Dispatchers.IO) {`);
+		lines.push(`    ${escapeReserved(methodName)}()`);
+		lines.push("  }");
+		return lines;
+	}
+	if (params.length === 1) {
+		const single = params[0].decl.replace(/^\s+/, "");
+		lines.push(`  suspend fun ${escapeReserved(suspendName)}(${single})${returnClause} = withContext(Dispatchers.IO) {`);
+	} else {
+		lines.push(`  suspend fun ${escapeReserved(suspendName)}(`);
+		for (let i = 0; i < params.length; i++) {
+			const suffix = i === params.length - 1 ? "" : ",";
+			lines.push(`${params[i].decl}${suffix}`);
+		}
+		lines.push(`  )${returnClause} = withContext(Dispatchers.IO) {`);
+	}
+	lines.push(`    ${escapeReserved(methodName)}(${callArgs})`);
+	lines.push("  }");
+	return lines;
+}
+/**
+* Imports a service file needs to declare any suspend overloads.
+*/
+const SUSPEND_IMPORTS = ["kotlinx.coroutines.Dispatchers", "kotlinx.coroutines.withContext"];
+function jvmNameLiteral(name) {
+	return JSON.stringify(name);
+}
+//#endregion
 //#region src/kotlin/wrappers.ts
 /**
 * Emit Kotlin wrapper methods for a union-split operation. Each wrapper
@@ -18206,31 +18411,48 @@ function emitWrapperMethod$1(resolvedOp, wrapper, ctx) {
 	if (opDesc) kdocLines.push(opDesc.split("\n")[0]);
 	else kdocLines.push(`${wrapperHumanName.charAt(0).toUpperCase()}${wrapperHumanName.slice(1)}.`);
 	const paramDocs = [];
-	for (const pp of pathParams) if (pp.description?.trim()) paramDocs.push(`@param ${propertyName(pp.name)} ${escapeKdoc$1(pp.description.split("\n")[0].trim())}`);
-	for (const rp of resolvedParams) {
-		const desc = rp.field?.description?.trim();
-		if (desc) paramDocs.push(`@param ${propertyName(rp.paramName)} ${escapeKdoc$1(desc.split("\n")[0])}`);
-	}
+	const pushParamDoc = (kotlinName, sourceName, description, type) => {
+		const firstLine = description?.split("\n").find((l) => l.trim())?.trim() ?? "";
+		const fallback = `the ${humanize(sourceName)} of the request.`;
+		let text = firstLine || fallback;
+		const shortened = maybeShortenEnumParamDescription(type, text);
+		if (shortened) text = shortened.description;
+		paramDocs.push(`@param ${kotlinName} ${escapeKdoc$1(text)}`);
+	};
+	for (const pp of pathParams) pushParamDoc(propertyName(pp.name), pp.name, pp.description, pp.type);
+	for (const rp of resolvedParams) pushParamDoc(propertyName(rp.paramName), rp.paramName, rp.field?.description, rp.field?.type);
+	pushParamDoc("requestOptions", "request_options", "per-request overrides (idempotency key, API key, headers, timeout)");
 	if (responseClass) paramDocs.push(`@return the ${responseClass}`);
-	if (paramDocs.length > 0 || kdocLines.length > 0) {
-		lines.push("  /**");
-		for (const l of kdocLines) lines.push(`   * ${escapeKdoc$1(l)}`);
-		if (paramDocs.length > 0) {
-			lines.push("   *");
-			for (const p of paramDocs) lines.push(`   * ${p}`);
-		}
-		lines.push("   */");
-	}
+	lines.push("  /**");
+	for (const l of kdocLines) lines.push(`   * ${escapeKdoc$1(l)}`);
+	lines.push("   *");
+	for (const p of paramDocs) lines.push(`   * ${p}`);
+	lines.push("   */");
 	lines.push("  @JvmOverloads");
 	const params = [];
-	for (const pp of pathParams) params.push(`    ${propertyName(pp.name)}: String`);
+	const suspendParams = [];
+	for (const pp of pathParams) {
+		const decl = `    ${propertyName(pp.name)}: String`;
+		params.push(decl);
+		suspendParams.push({
+			decl,
+			name: propertyName(pp.name)
+		});
+	}
 	for (const rp of resolvedParams) {
 		const paramName = propertyName(rp.paramName);
-		const kotlinType = rp.field ? rp.isOptional ? mapTypeRefOptional(rp.field.type) : mapTypeRef$1(rp.field.type) : rp.isOptional ? "String?" : "String";
-		const trailer = rp.isOptional ? " = null" : "";
-		params.push(`    ${paramName}: ${kotlinType}${trailer}`);
+		const decl = `    ${paramName}: ${rp.field ? rp.isOptional ? mapTypeRefOptional(rp.field.type) : mapTypeRef$1(rp.field.type) : rp.isOptional ? "String?" : "String"}${rp.isOptional ? " = null" : ""}`;
+		params.push(decl);
+		suspendParams.push({
+			decl,
+			name: paramName
+		});
 	}
 	params.push("    requestOptions: RequestOptions? = null");
+	suspendParams.push({
+		decl: "    requestOptions: RequestOptions? = null",
+		name: "requestOptions"
+	});
 	const returnClause = responseClass ? `: ${responseClass}` : "";
 	if (params.length === 1) {
 		const single = params[0].replace(/^\s+/, "");
@@ -18243,6 +18465,26 @@ function emitWrapperMethod$1(resolvedOp, wrapper, ctx) {
 		}
 		lines.push(`  )${returnClause} {`);
 	}
+	const inferred = wrapper.inferFromClient ?? [];
+	const usesStandardClientCreds = inferred.includes("client_id") && inferred.includes("client_secret");
+	if (op.path === "/user_management/authenticate" && op.httpMethod.toUpperCase() === "POST" && responseClass === "AuthenticateResponse" && typeof wrapper.defaults?.grant_type === "string" && usesStandardClientCreds) {
+		const grantType = wrapper.defaults.grant_type;
+		lines.push(`    return authenticate(`);
+		lines.push(`      grantType = ${ktLiteral(grantType)},`);
+		lines.push(`      requestOptions = requestOptions,`);
+		const entryLines = resolvedParams.map((rp) => {
+			const paramName = propertyName(rp.paramName);
+			return `      ${ktLiteral(rp.paramName)} to ${paramName}`;
+		});
+		for (let i = 0; i < entryLines.length; i++) {
+			const sep = i === entryLines.length - 1 ? "" : ",";
+			lines.push(`${entryLines[i]}${sep}`);
+		}
+		lines.push(`    )`);
+		lines.push("  }");
+		appendSuspendVariant(lines, method, suspendParams, responseClass ?? "Unit");
+		return lines;
+	}
 	const bodyEntries = [];
 	for (const rp of resolvedParams) {
 		const paramName = propertyName(rp.paramName);
@@ -18272,8 +18514,17 @@ function emitWrapperMethod$1(resolvedOp, wrapper, ctx) {
 	if (responseClass) lines.push(`    return workos.baseClient.request(config, ${responseClass}::class.java)`);
 	else lines.push(`    workos.baseClient.requestVoid(config)`);
 	lines.push("  }");
+	appendSuspendVariant(lines, method, suspendParams, responseClass ?? "Unit");
 	return lines;
 }
+function appendSuspendVariant(lines, method, suspendParams, returnType) {
+	lines.push("");
+	for (const ln of emitSuspendVariant({
+		methodName: method,
+		params: suspendParams,
+		returnType
+	})) lines.push(ln);
+}
 function escapeKdoc$1(s) {
 	return s.replace(/\*\//g, "*​/");
 }
@@ -18301,6 +18552,52 @@ function isHandwrittenOverride(op) {
 //#region src/kotlin/resources.ts
 const KOTLIN_SRC_PREFIX$1 = "src/main/kotlin/";
 /**
+* Some specs leave query params / fields typed as plain `string` even though
+* the description (or the field name) makes clear they carry an ISO-8601
+* timestamp. Detecting that here lets us emit `OffsetDateTime` so callers
+* don't have to format the wire string themselves.
+*/
+const ISO_8601_DESCRIPTION_RE$1 = /\bISO[-_ ]?8601\b/i;
+function looksLikeIso8601String$1(description) {
+	if (!description) return false;
+	return ISO_8601_DESCRIPTION_RE$1.test(description);
+}
+/**
+* Promote a string `TypeRef` to a `format: date-time` primitive when the
+* accompanying description identifies it as an ISO-8601 timestamp. Leaves
+* non-string types untouched.
+*/
+function promoteIso8601TypeRef$1(type, description) {
+	if (!looksLikeIso8601String$1(description)) return type;
+	const promote = (t) => {
+		if (t.kind === "primitive" && t.type === "string" && !t.format) return {
+			kind: "primitive",
+			type: "string",
+			format: "date-time"
+		};
+		if (t.kind === "nullable") return {
+			kind: "nullable",
+			inner: promote(t.inner)
+		};
+		return t;
+	};
+	return promote(type);
+}
+function promoteParameterType(p) {
+	const promoted = promoteIso8601TypeRef$1(p.type, p.description);
+	return promoted === p.type ? p : {
+		...p,
+		type: promoted
+	};
+}
+function promoteFieldType(f) {
+	const promoted = promoteIso8601TypeRef$1(f.type, f.description);
+	return promoted === f.type ? f : {
+		...f,
+		type: promoted
+	};
+}
+/**
 * Generate one API class per mount group. Methods map 1:1 to IR operations.
 * Path params, query params, and body fields are flattened into the method
 * signature so callers never need to construct an intermediate options object.
@@ -18332,6 +18629,7 @@ function generateApiClass(mountName, operations, ctx, resolvedLookup) {
 	imports.add("com.workos.common.http.Page");
 	imports.add("com.workos.common.http.RequestConfig");
 	imports.add("com.workos.common.http.RequestOptions");
+	for (const imp of SUSPEND_IMPORTS) imports.add(imp);
 	const body = [];
 	const seenMethods = /* @__PURE__ */ new Set();
 	if (operations.some((op) => op.path === "/user_management/authenticate" && op.httpMethod.toUpperCase() === "POST")) {
@@ -18386,15 +18684,21 @@ function generateApiClass(mountName, operations, ctx, resolvedLookup) {
 	lines.push("");
 	for (const line of sealedLines) lines.push(line);
 	const serviceDescription = resolveServiceDescription(ctx, mountName, operations);
+	const suspendNote = "Every operation on this class is available in two flavors: a blocking variant (`<methodName>`) and a coroutine-aware variant (`<methodName>Suspend`). The `Suspend` variants delegate to the blocking ones under `withContext(Dispatchers.IO)`, so they are safe to call from any coroutine dispatcher (including `Dispatchers.Main`).";
 	if (serviceDescription) {
 		const docLines = serviceDescription.trim().split("\n");
-		if (docLines.length === 1) lines.push(`/** ${escapeKdoc(docLines[0].trim())} */`);
-		else {
-			lines.push("/**");
-			for (const l of docLines) lines.push(l ? ` * ${escapeKdoc(l)}` : " *");
-			lines.push(" */");
-		}
-	} else lines.push(`/** API accessor for ${mountName}. */`);
+		lines.push("/**");
+		for (const l of docLines) lines.push(l ? ` * ${escapeKdoc(l)}` : " *");
+		lines.push(" *");
+		lines.push(` * ${escapeKdoc(suspendNote)}`);
+		lines.push(" */");
+	} else {
+		lines.push("/**");
+		lines.push(` * API accessor for ${mountName}.`);
+		lines.push(" *");
+		lines.push(` * ${escapeKdoc(suspendNote)}`);
+		lines.push(" */");
+	}
 	lines.push(`class ${apiClass}(`);
 	lines.push("  internal val workos: WorkOS");
 	lines.push(`) {`);
@@ -18431,9 +18735,9 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 	const pathParams = sortPathParamsByTemplateOrder(op);
 	const groupedParamNames = collectGroupedParamNames(op);
 	const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
-	const queryParams = op.queryParams.filter((p) => !hidden.has(p.name) && !groupedParamNames.has(p.name));
+	const queryParams = op.queryParams.filter((p) => !hidden.has(p.name) && !groupedParamNames.has(p.name)).map(promoteParameterType);
 	const bodyModel = resolveBodyModel$2(op, ctx);
-	const bodyFields = bodyModel ? bodyModel.fields.filter((f) => !hidden.has(f.name) && !groupedParamNames.has(f.name)) : [];
+	const bodyFields = bodyModel ? bodyModel.fields.filter((f) => !hidden.has(f.name) && !groupedParamNames.has(f.name)).map(promoteFieldType) : [];
 	for (const p of [...pathParams, ...queryParams]) registerTypeImports(p.type, imports, ctx);
 	for (const f of bodyFields) registerTypeImports(f.type, imports, ctx);
 	const paginatedItemName = resolvePaginatedItemName(plan.paginatedItemModelName, ctx);
@@ -18465,14 +18769,22 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 	}
 	const groupParamNames = assignGroupParameterNames$1(op, paramNames);
 	const params = [];
-	for (const pp of pathParams) params.push(`    ${propertyName(pp.name)}: String`);
+	const suspendParams = [];
+	const pushParam = (decl, name) => {
+		params.push(decl);
+		suspendParams.push({
+			decl,
+			name
+		});
+	};
+	for (const pp of pathParams) pushParam(`    ${propertyName(pp.name)}: String`, propertyName(pp.name));
 	const sortedQuery = [...uniqueQuery].sort((a, b) => a.required === b.required ? 0 : a.required ? -1 : 1);
-	for (const qp of sortedQuery) params.push(renderParam(qp.name, qp.type, qp.required, method.startsWith("list") && qp.name === "limit"));
+	for (const qp of sortedQuery) pushParam(renderParam(qp.name, qp.type, qp.required, method.startsWith("list") && qp.name === "limit"), propertyName(qp.name));
 	for (const group of op.parameterGroups ?? []) {
 		const sealedName = sealedGroupName$1(group.name);
 		const prop = groupParamNames.get(group.name);
-		if (group.optional) params.push(`    ${prop}: ${sealedName}? = null`);
-		else params.push(`    ${prop}: ${sealedName}`);
+		if (group.optional) pushParam(`    ${prop}: ${sealedName}? = null`, prop);
+		else pushParam(`    ${prop}: ${sealedName}`, prop);
 	}
 	const isPatch = httpMethod === "PATCH";
 	const sortedBodyFields = [...bodyFields].sort((a, b) => a.required === b.required ? 0 : a.required ? -1 : 1);
@@ -18481,10 +18793,10 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 		if (isPatch && !bf.required) {
 			const baseType = mapTypeRef$1(bf.type);
 			imports.add("com.workos.common.http.PatchField");
-			params.push(`    ${bodyParamNames.get(bf.name)}: PatchField<${baseType}> = PatchField.Absent`);
-		} else params.push(renderParamNamed(bodyParamNames.get(bf.name), bf.type, bf.required));
+			pushParam(`    ${bodyParamNames.get(bf.name)}: PatchField<${baseType}> = PatchField.Absent`, bodyParamNames.get(bf.name));
+		} else pushParam(renderParamNamed(bodyParamNames.get(bf.name), bf.type, bf.required), bodyParamNames.get(bf.name));
 	}
-	params.push("    requestOptions: RequestOptions? = null");
+	pushParam("    requestOptions: RequestOptions? = null", "requestOptions");
 	const returnType = resolveReturnType(plan, imports, ctx);
 	const isPaginated = plan.isPaginated && paginatedItemName !== null;
 	const lines = [];
@@ -18528,6 +18840,7 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 		}
 		lines.push(`    )`);
 		lines.push("  }");
+		appendSuspendVariantLines(lines, method, suspendParams, returnType, op.deprecated);
 		return lines.join("\n");
 	}
 	if (isPaginated) {
@@ -18544,9 +18857,8 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 		lines.push(`      before = ${pickNamedQueryParam(sortedQuery, "before")},`);
 		lines.push(`      after = ${pickNamedQueryParam(sortedQuery, "after")}`);
 		lines.push(`    ) {`);
-		lines.push(`      val params = this`);
-		for (const qp of sortedQuery.filter((p) => p.name !== "after" && p.name !== "before")) for (const ln of emitQueryParam(qp, "      ")) lines.push(ln);
-		for (const group of op.parameterGroups ?? []) for (const ln of emitGroupQueryDispatch(group, groupParamNames.get(group.name), "      ")) lines.push(ln);
+		for (const qp of sortedQuery.filter((p) => p.name !== "after" && p.name !== "before")) for (const ln of emitQueryParam(qp, "      ", true)) lines.push(ln);
+		for (const group of op.parameterGroups ?? []) for (const ln of emitGroupQueryDispatch(group, groupParamNames.get(group.name), "      ", true)) lines.push(ln);
 		lines.push(`    }`);
 	} else {
 		const groupsGoToQuery = hasGroups && !hasBody;
@@ -18612,8 +18924,123 @@ function renderMethod(_mountName, method, op, ctx, resolvedOp, imports) {
 		else lines.push(`    workos.baseClient.requestVoid(config)`);
 	}
 	lines.push("  }");
+	appendSuspendVariantLines(lines, method, suspendParams, returnType, op.deprecated);
+	appendJavaFriendlyVariantOverloads(lines, {
+		method,
+		op,
+		canonicalParams: suspendParams,
+		groupParamNames,
+		returnType,
+		deprecated: op.deprecated
+	});
 	return lines.join("\n");
 }
+/**
+* For each variant of every sealed-class parameter group on `op`, append a
+* Java-discoverable overload that takes the variant's flat fields directly
+* and forwards to the canonical (sealed-class) method.
+*
+* Implementation scope: when an operation has multiple parameter groups, we
+* emit overloads for each variant of each group while keeping the *other*
+* groups' sealed-class params unchanged. This avoids combinatorial explosion
+* for ops with several groups while still flattening the common case.
+*
+* Method-name derivation handles the most common variant shapes (`ById`,
+* `ByExternalId`, etc.). Other shapes (e.g. `Plaintext`, `Imported`) are
+* skipped with a comment so unusual unions don't compile-fail the SDK; if
+* one becomes important we can add an explicit case here.
+*/
+function appendJavaFriendlyVariantOverloads(lines, ctx) {
+	const groups = ctx.op.parameterGroups ?? [];
+	if (groups.length === 0) return;
+	for (const group of groups) for (const variant of group.variants) {
+		const overloadMethodName = deriveOverloadMethodName(ctx.method, variant.name);
+		if (overloadMethodName === null) continue;
+		emitOneJavaOverload(lines, ctx, group, variant, overloadMethodName);
+	}
+}
+function deriveOverloadMethodName(baseMethod, variantName) {
+	const v = className$1(variantName);
+	if (v === "ById") return baseMethod;
+	if (/^By[A-Z]/.test(v)) {
+		if (baseMethod.toLowerCase().endsWith(v.toLowerCase())) return baseMethod;
+		return `${baseMethod}${v}`;
+	}
+	return null;
+}
+function emitOneJavaOverload(lines, ctx, group, variant, overloadMethodName) {
+	const sealedName = sealedGroupName$1(group.name);
+	const variantClass = className$1(variant.name);
+	const targetGroupProp = ctx.groupParamNames.get(group.name);
+	const decls = [];
+	const existingNames = /* @__PURE__ */ new Set();
+	for (const cp of ctx.canonicalParams) if (cp.name !== targetGroupProp) existingNames.add(cp.name);
+	const variantFieldDecls = [];
+	const variantArgPairs = [];
+	for (const p of variant.parameters) {
+		const sealedField = deriveShortPropertyName(p.name, group.name);
+		let localName = sealedField;
+		if (existingNames.has(localName)) localName = `${propertyName(group.name)}${localName.charAt(0).toUpperCase()}${localName.slice(1)}`;
+		existingNames.add(localName);
+		const decl = renderParamNamed(localName, p.type, true);
+		variantFieldDecls.push({
+			decl,
+			name: localName
+		});
+		variantArgPairs.push({
+			sealedField,
+			localName
+		});
+	}
+	for (const cp of ctx.canonicalParams) if (cp.name === targetGroupProp) for (const v of variantFieldDecls) decls.push(v);
+	else decls.push({
+		decl: cp.decl,
+		name: cp.name
+	});
+	const returnClause = ctx.returnType === "Unit" ? "" : `: ${ctx.returnType}`;
+	const sealedConstruct = `${sealedName}.${variantClass}(${variantArgPairs.map((p) => `${p.sealedField} = ${p.localName}`).join(", ")})`;
+	const forwardArgs = [];
+	for (const cp of ctx.canonicalParams) if (cp.name === targetGroupProp) forwardArgs.push(`${cp.name} = ${sealedConstruct}`);
+	else forwardArgs.push(`${cp.name} = ${cp.name}`);
+	lines.push("");
+	lines.push("  /**");
+	lines.push(`   * Java-friendly overload — equivalent to`);
+	lines.push(`   * \`${ctx.method}(${sealedName}.${variantClass}(...))\` from Kotlin.`);
+	lines.push(`   *`);
+	lines.push(`   * Accepts the discriminating fields directly so Java callers don't`);
+	lines.push(`   * need to construct \`${sealedName}.${variantClass}\` explicitly.`);
+	lines.push("   */");
+	if (ctx.deprecated) lines.push("  @Deprecated(\"Deprecated operation\")");
+	if (decls.length === 1) {
+		const single = decls[0].decl.replace(/^\s+/, "");
+		lines.push(`  fun ${escapeReserved(overloadMethodName)}(${single})${returnClause} = ${ctx.method}(`);
+	} else {
+		lines.push(`  fun ${escapeReserved(overloadMethodName)}(`);
+		for (let i = 0; i < decls.length; i++) {
+			const sep = i === decls.length - 1 ? "" : ",";
+			lines.push(`${decls[i].decl}${sep}`);
+		}
+		lines.push(`  )${returnClause} = ${ctx.method}(`);
+	}
+	for (let i = 0; i < forwardArgs.length; i++) {
+		const sep = i === forwardArgs.length - 1 ? "" : ",";
+		lines.push(`    ${forwardArgs[i]}${sep}`);
+	}
+	lines.push("  )");
+	appendSuspendVariantLines(lines, overloadMethodName, decls.map((d) => ({
+		decl: d.decl,
+		name: d.name
+	})), ctx.returnType, ctx.deprecated);
+}
+function appendSuspendVariantLines(lines, method, suspendParams, returnType, deprecated) {
+	lines.push("");
+	for (const ln of emitSuspendVariant({
+		methodName: method,
+		params: suspendParams,
+		returnType,
+		deprecated
+	})) lines.push(ln);
+}
 function resolveReturnType(plan, imports, ctx) {
 	const itemName = plan.isPaginated ? resolvePaginatedItemName(plan.paginatedItemModelName, ctx) ?? plan.paginatedItemModelName : null;
 	if (plan.isPaginated && itemName) {
@@ -18666,14 +19093,15 @@ function buildMethodKdoc(op, pathParams, queryParams, bodyFields, bodyParamNames
 	if (descriptionRaw) for (const l of descriptionRaw.split("\n")) textLines.push(escapeKdoc(l));
 	const paramDocs = [];
 	const seenParamDocs = /* @__PURE__ */ new Set();
-	const pushParamDoc = (name, description, deprecated) => {
+	const pushParamDoc = (name, sourceName, description, deprecated, type) => {
 		if (seenParamDocs.has(name)) return;
 		seenParamDocs.add(name);
-		paramDocs.push(formatParamDoc(name, description, deprecated));
+		paramDocs.push(formatParamDoc(name, description, deprecated, sourceName, type));
 	};
-	for (const pp of pathParams) if (pp.description?.trim() || pp.deprecated) pushParamDoc(propertyName(pp.name), pp.description, pp.deprecated);
-	for (const qp of queryParams) if (qp.description?.trim() || qp.deprecated) pushParamDoc(propertyName(qp.name), qp.description, qp.deprecated);
-	for (const bf of bodyFields) if (bf.description?.trim() || bf.deprecated) pushParamDoc(bodyParamNames.get(bf.name), bf.description, bf.deprecated);
+	for (const pp of pathParams) pushParamDoc(propertyName(pp.name), pp.name, pp.description, pp.deprecated, pp.type);
+	for (const qp of queryParams) pushParamDoc(propertyName(qp.name), qp.name, qp.description, qp.deprecated, qp.type);
+	for (const bf of bodyFields) pushParamDoc(bodyParamNames.get(bf.name), bf.name, bf.description, bf.deprecated, bf.type);
+	pushParamDoc("requestOptions", "request_options", REQUEST_OPTIONS_PARAM_DESCRIPTION);
 	const returnDoc = plan.isPaginated ? "@return a [com.workos.common.http.Page] of results" : plan.responseModelName ? `@return the ${plan.isArrayResponse ? `list of ${className$1(plan.responseModelName)}` : className$1(plan.responseModelName)}` : null;
 	if (!(textLines.length > 0 || paramDocs.length > 0 || returnDoc !== null)) return [];
 	const out = ["  /**"];
@@ -18687,10 +19115,20 @@ function buildMethodKdoc(op, pathParams, queryParams, bodyFields, bodyParamNames
 	out.push("   */");
 	return out;
 }
-function formatParamDoc(kotlinName, description, deprecated) {
-	const text = (description?.split("\n").find((l) => l.trim()) ?? "").trim();
-	const parts = [deprecated ? "**Deprecated.**" : "", text].filter(Boolean).join(" ");
-	return `@param ${kotlinName}${parts ? ` ${escapeKdoc(parts)}` : ""}`;
+/**
+* Stable, canned description for the trailing `requestOptions` parameter that
+* every generated method exposes. Kept as a constant so the same phrasing
+* appears across resource methods, wrapper methods, and union-split helpers.
+*/
+const REQUEST_OPTIONS_PARAM_DESCRIPTION = "per-request overrides (idempotency key, API key, headers, timeout)";
+function formatParamDoc(kotlinName, description, deprecated, sourceName, type) {
+	const specText = (description?.split("\n").find((l) => l.trim()) ?? "").trim();
+	const deprecationNote = deprecated ? "**Deprecated.**" : "";
+	const fallback = `the ${humanize(sourceName ?? kotlinName)} of the request.`;
+	let text = specText || fallback;
+	const shortened = maybeShortenEnumParamDescription(type, text);
+	if (shortened) text = shortened.description;
+	return `@param ${kotlinName} ${escapeKdoc([deprecationNote, text].filter(Boolean).join(" "))}`;
 }
 /**
 * Unwrap a possibly-nullable type to check if the inner type is an array,
@@ -18709,32 +19147,43 @@ function unwrapArray(t) {
 function valueExprForQuery(type) {
 	const inner = type.kind === "nullable" ? type.inner : type;
 	if (inner.kind === "enum") return "it.value";
-	if (inner.kind === "primitive" && inner.type === "string") return "it";
+	if (inner.kind === "primitive" && inner.type === "string") return inner.format === "date-time" ? "it.toString()" : "it";
 	return "it.toString()";
 }
-function emitQueryParam(p, indent) {
+function emitQueryParam(p, indent, receiverMode = false) {
 	const prop = propertyName(p.name);
 	const rendered = queryParamToString(p.type, prop);
 	const inner = p.type.kind === "nullable" ? p.type.inner : p.type;
 	const arrayItem = unwrapArray(p.type);
+	const callPrefix = receiverMode ? "" : "params.";
+	const addPair = (pair) => receiverMode ? `add(${pair})` : `params += ${pair}`;
 	if (arrayItem) {
 		const explode = p.explode ?? true;
 		const itemExpr = valueExprForQuery(arrayItem);
+		const isIdentity = itemExpr === "it";
 		if (!explode) {
-			if (p.required) return [`${indent}params.addJoinedIfNotNull(${ktLiteral(p.name)}, ${prop}.map { ${itemExpr} })`];
-			return [`${indent}params.addJoinedIfNotNull(${ktLiteral(p.name)}, ${prop}?.map { ${itemExpr} })`];
+			if (p.required) {
+				const arg = isIdentity ? prop : `${prop}.map { ${itemExpr} }`;
+				return [`${indent}${callPrefix}addJoinedIfNotNull(${ktLiteral(p.name)}, ${arg})`];
+			}
+			const arg = isIdentity ? prop : `${prop}?.map { ${itemExpr} }`;
+			return [`${indent}${callPrefix}addJoinedIfNotNull(${ktLiteral(p.name)}, ${arg})`];
+		}
+		if (p.required) {
+			const arg = isIdentity ? prop : `${prop}.map { ${itemExpr} }`;
+			return [`${indent}${callPrefix}addEach(${ktLiteral(p.name)}, ${arg})`];
 		}
-		if (p.required) return [`${indent}params.addEach(${ktLiteral(p.name)}, ${prop}.map { ${itemExpr} })`];
-		return [`${indent}${prop}?.let { params.addEach(${ktLiteral(p.name)}, it.map { ${itemExpr} }) }`];
+		if (isIdentity) return [`${indent}${prop}?.let { ${callPrefix}addEach(${ktLiteral(p.name)}, it) }`];
+		return [`${indent}${prop}?.let { ${callPrefix}addEach(${ktLiteral(p.name)}, it.map { ${itemExpr} }) }`];
 	}
-	if (p.required) return [`${indent}params += ${ktLiteral(p.name)} to ${rendered}`];
-	if (inner.kind === "primitive" && inner.type === "string") return [`${indent}params.addIfNotNull(${ktLiteral(p.name)}, ${prop})`];
-	return [`${indent}${prop}?.let { params += ${ktLiteral(p.name)} to ${queryParamToString(inner, "it")} }`];
+	if (p.required) return [`${indent}${addPair(`${ktLiteral(p.name)} to ${rendered}`)}`];
+	if (inner.kind === "primitive" && inner.type === "string" && inner.format !== "date-time") return [`${indent}${callPrefix}addIfNotNull(${ktLiteral(p.name)}, ${prop})`];
+	return [`${indent}${prop}?.let { ${addPair(`${ktLiteral(p.name)} to ${queryParamToString(inner, "it")}`)} }`];
 }
 function queryParamToString(type, varName) {
 	if (type.kind === "enum") return `${varName}.value`;
 	if (type.kind === "nullable") return queryParamToString(type.inner, varName);
-	if (type.kind === "primitive" && type.type === "string") return varName;
+	if (type.kind === "primitive" && type.type === "string") return type.format === "date-time" ? `${varName}.toString()` : varName;
 	return `${varName}.toString()`;
 }
 function pickNamedQueryParam(sorted, name) {
@@ -18822,7 +19271,26 @@ function deriveShortPropertyName(paramName, groupName) {
 function generateSealedClass(group, bodyFieldTypes) {
 	const lines = [];
 	const sealedName = sealedGroupName$1(group.name);
-	lines.push(`/** Mutually exclusive ${humanize(group.name)} parameter variants. */`);
+	const example = group.variants[0];
+	if (example) {
+		const exampleVariant = className$1(example.name);
+		const exampleArgs = example.parameters.map((p) => `${deriveShortPropertyName(p.name, group.name)} = "..."`).join(", ");
+		lines.push("/**");
+		lines.push(` * Mutually exclusive ${humanize(group.name)} parameter variants.`);
+		lines.push(" *");
+		lines.push(" * Usage from Kotlin:");
+		lines.push(" * ```kotlin");
+		lines.push(` * val target: ${sealedName} = ${sealedName}.${exampleVariant}(${exampleArgs})`);
+		lines.push(" * ```");
+		lines.push(" *");
+		lines.push(" * Usage from Java:");
+		lines.push(" * ```java");
+		lines.push(` * ${sealedName} target = new ${sealedName}.${exampleVariant}(${example.parameters.map(() => "\"...\"").join(", ")});`);
+		lines.push(" * ```");
+		lines.push(" *");
+		lines.push(` * Java callers may also use the per-variant overloads on the surrounding API class to skip variant construction entirely.`);
+		lines.push(" */");
+	} else lines.push(`/** Mutually exclusive ${humanize(group.name)} parameter variants. */`);
 	lines.push(`sealed class ${sealedName} {`);
 	for (let vi = 0; vi < group.variants.length; vi++) {
 		const variant = group.variants[vi];
@@ -18848,14 +19316,14 @@ function generateSealedClass(group, bodyFieldTypes) {
 	return lines;
 }
 /** Emit `when` dispatch that serializes a parameter group into query params. */
-function emitGroupQueryDispatch(group, prop, indent) {
+function emitGroupQueryDispatch(group, prop, indent, receiverMode = false) {
 	const sealedName = sealedGroupName$1(group.name);
 	const lines = [];
 	if (group.optional) {
 		lines.push(`${indent}if (${prop} != null) {`);
-		emitWhenBlock(lines, group, sealedName, prop, `${indent}  `);
+		emitWhenBlock(lines, group, sealedName, prop, `${indent}  `, receiverMode);
 		lines.push(`${indent}}`);
-	} else emitWhenBlock(lines, group, sealedName, prop, indent);
+	} else emitWhenBlock(lines, group, sealedName, prop, indent, receiverMode);
 	return lines;
 }
 function assignGroupParameterNames$1(op, occupiedNames) {
@@ -18882,13 +19350,14 @@ function reserveUniqueGroupParameterName$1(base, occupiedNames) {
 	occupiedNames.add(fallback);
 	return fallback;
 }
-function emitWhenBlock(lines, group, sealedName, prop, indent) {
+function emitWhenBlock(lines, group, sealedName, prop, indent, receiverMode = false) {
 	lines.push(`${indent}when (${prop}) {`);
 	for (const variant of group.variants) {
 		const variantName = className$1(variant.name);
 		const entries = variant.parameters.map((p) => {
 			const fieldProp = deriveShortPropertyName(p.name, group.name);
-			return `params += ${ktLiteral(p.name)} to ${prop}.${fieldProp}`;
+			const pair = `${ktLiteral(p.name)} to ${prop}.${fieldProp}`;
+			return receiverMode ? `add(${pair})` : `params += ${pair}`;
 		});
 		if (entries.length === 1) lines.push(`${indent}  is ${sealedName}.${variantName} -> ${entries[0]}`);
 		else {
@@ -18944,30 +19413,36 @@ const KOTLIN_SRC_PREFIX = "src/main/kotlin/";
 * contains a `WorkOS` class stub with only these properties — the oagen
 * merger deep-merges them into the existing hand-written `WorkOS.kt`.
 *
-* Accessors use fully-qualified type names so the merger doesn't need to
-* inject imports into the hand-written file.
+* Each referenced service class is hoisted into a top-level `import` so the
+* accessor bodies use the short class name. The live `WorkOS.kt` is marked
+* `@oagen-ignore-file` and won't be regenerated, but the emitter still emits
+* the cleaner shape so future regenerations don't reintroduce the FQN noise.
 */
 function generateClient$1(spec, ctx) {
 	const targets = deduplicateByMount(spec.services, ctx);
 	if (targets.length === 0) return [];
+	const imports = /* @__PURE__ */ new Set();
 	const accessorLines = [];
 	for (const mount of targets) {
 		const apiCls = apiClassName(mount);
 		const fqn = `com.workos.${packageSegment(mount)}.${apiCls}`;
+		imports.add(fqn);
 		const prop = servicePropertyName$1(mount);
 		accessorLines.push("");
-		accessorLines.push(`  /** Lazily-constructed [${fqn}] accessor for this [WorkOS] client. */`);
-		accessorLines.push(`  val ${prop}: ${fqn}`);
+		accessorLines.push(`  /** Lazily-constructed [${apiCls}] accessor for this [WorkOS] client. */`);
+		accessorLines.push(`  val ${prop}: ${apiCls}`);
 		accessorLines.push("    get() =");
 		accessorLines.push("      service(");
-		accessorLines.push(`        ${fqn}::class`);
+		accessorLines.push(`        ${apiCls}::class`);
 		accessorLines.push("      ) {");
-		accessorLines.push(`        ${fqn}(this)`);
+		accessorLines.push(`        ${apiCls}(this)`);
 		accessorLines.push("      }");
 	}
 	const lines = [];
 	lines.push("package com.workos");
 	lines.push("");
+	for (const imp of [...imports].sort()) lines.push(`import ${imp}`);
+	if (imports.size > 0) lines.push("");
 	lines.push("open class WorkOS {");
 	for (const line of accessorLines) lines.push(line);
 	lines.push("}");
@@ -18986,6 +19461,33 @@ function deduplicateByMount(services, ctx) {
 //#region src/kotlin/tests.ts
 const TEST_PREFIX = "src/test/kotlin/";
 /**
+* Mirror the ISO-8601 hint promotion the resource/model emitters use so tests
+* synthesize values whose Kotlin type matches the generated method signature.
+* Kept in sync with the helpers in `resources.ts` / `models.ts`; if the
+* detection rule changes, update all three.
+*/
+const ISO_8601_DESCRIPTION_RE = /\bISO[-_ ]?8601\b/i;
+function looksLikeIso8601String(description) {
+	if (!description) return false;
+	return ISO_8601_DESCRIPTION_RE.test(description);
+}
+function promoteIso8601TypeRef(type, description) {
+	if (!looksLikeIso8601String(description)) return type;
+	const promote = (t) => {
+		if (t.kind === "primitive" && t.type === "string" && !t.format) return {
+			kind: "primitive",
+			type: "string",
+			format: "date-time"
+		};
+		if (t.kind === "nullable") return {
+			kind: "nullable",
+			inner: promote(t.inner)
+		};
+		return t;
+	};
+	return promote(type);
+}
+/**
 * Generate one JUnit 5 + WireMock test class per API mount group, plus a
 * cross-cutting model round-trip test.
 *
@@ -19120,10 +19622,11 @@ function buildOperationTest(op, resolved, ctx) {
 	}
 	for (const qp of sortedQuery) {
 		if (!qp.required) break;
-		const val = synthValue(qp.type, ctx, imports);
+		const promotedType = promoteIso8601TypeRef(qp.type, qp.description);
+		const val = synthValue(promotedType, ctx, imports);
 		if (val === null) return null;
 		argParts.push(val);
-		const regex = queryValueRegexFor(qp.type);
+		const regex = queryValueRegexFor(promotedType);
 		if (regex !== null) requiredQueryAssertions.push({
 			name: qp.name,
 			valueRegex: regex
@@ -19143,10 +19646,11 @@ function buildOperationTest(op, resolved, ctx) {
 		for (const bf of sortedBody) {
 			if (sharedQueryBodyParams.has(bf.name)) continue;
 			if (!bf.required) break;
-			const val = synthValue(bf.type, ctx, imports);
+			const promotedType = promoteIso8601TypeRef(bf.type, bf.description);
+			const val = synthValue(promotedType, ctx, imports);
 			if (val === null) return null;
 			argParts.push(val);
-			if (isScalarBodyField(bf.type)) requiredBodyPaths.push(bf.name);
+			if (isScalarBodyField(promotedType)) requiredBodyPaths.push(bf.name);
 		}
 	}
 	const plan2 = plan;
@@ -19264,7 +19768,7 @@ function buildWrapperTest(op, wrapper, ctx) {
 			argParts.push(ktStringLiteral("sample-arg"));
 			continue;
 		}
-		const val = synthValue(rp.field.type, ctx, imports);
+		const val = synthValue(promoteIso8601TypeRef(rp.field.type, rp.field.description), ctx, imports);
 		if (val === null) return null;
 		argParts.push(val);
 	}
@@ -19886,11 +20390,7 @@ const kotlinEmitter = {
 		if (!fs.existsSync(path.join(targetDir, "gradlew"))) return null;
 		return {
 			cmd: "bash",
-			args: [
-				"-c",
-				`cd ${JSON.stringify(targetDir)} && ./gradlew ktlintFormat --quiet 2>/dev/null; true`,
-				"--"
-			]
+			args: ["-c", "./gradlew ktlintFormat --quiet >/dev/null 2>&1; true"]
 		};
 	}
 };
@@ -22300,4 +22800,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { nodeEmitter as _, rustExtractor as a, pythonExtractor as c, rubyEmitter as d, kotlinEmitter as f, pythonEmitter as g, phpEmitter as h, kotlinExtractor as i, rubyExtractor as l, goEmitter as m, elixirExtractor as n, goExtractor as o, dotnetEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u };
 
-//# sourceMappingURL=plugin-DOE0FqrZ.mjs.map
+//# sourceMappingURL=plugin-Dh9JSScr.mjs.map