@workos/oagen-emitters 0.8.1 → 0.8.2

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.8.1"
+  ".": "0.8.2"
 }

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.8.2](https://github.com/workos/oagen-emitters/compare/v0.8.1...v0.8.2) (2026-05-05)
+
+
+### Bug Fixes
+
+* **kotlin:** improve emitter output quality ([#86](https://github.com/workos/oagen-emitters/issues/86)) ([6dd9b2a](https://github.com/workos/oagen-emitters/commit/6dd9b2ad6904ebb088cba65801d4987a2af61482))
+
 ## [0.8.1](https://github.com/workos/oagen-emitters/compare/v0.8.0...v0.8.1) (2026-05-05)
 
 

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { _ as nodeEmitter, a as rustExtractor, c as pythonExtractor, d as rubyEmitter, f as kotlinEmitter, g as pythonEmitter, h as phpEmitter, i as kotlinExtractor, l as rubyExtractor, m as goEmitter, n as elixirExtractor, o as goExtractor, p as dotnetEmitter, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor } from "./plugin-DOE0FqrZ.mjs";
+import { _ as nodeEmitter, a as rustExtractor, c as pythonExtractor, d as rubyEmitter, f as kotlinEmitter, g as pythonEmitter, h as phpEmitter, i as kotlinExtractor, l as rubyExtractor, m as goEmitter, n as elixirExtractor, o as goExtractor, p as dotnetEmitter, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor } from "./plugin-CeNME04k.mjs";
 export { dotnetEmitter, dotnetExtractor, elixirExtractor, goEmitter, goExtractor, kotlinEmitter, kotlinExtractor, nodeEmitter, nodeExtractor, phpEmitter, phpExtractor, pythonEmitter, pythonExtractor, rubyEmitter, rubyExtractor, rustExtractor, workosEmittersPlugin };

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

@@ -17749,6 +17749,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
@@ -17985,7 +18019,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 +18039,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 +18070,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 +18104,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)) {
@@ -18206,21 +18262,21 @@ 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) => {
+		const firstLine = description?.split("\n").find((l) => l.trim())?.trim() ?? "";
+		const fallback = `the ${humanize(sourceName)} of the request.`;
+		const text = firstLine || fallback;
+		paramDocs.push(`@param ${kotlinName} ${escapeKdoc$1(text)}`);
+	};
+	for (const pp of pathParams) pushParamDoc(propertyName(pp.name), pp.name, pp.description);
+	for (const rp of resolvedParams) pushParamDoc(propertyName(rp.paramName), rp.paramName, rp.field?.description);
+	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`);
@@ -18243,6 +18299,25 @@ 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("  }");
+		return lines;
+	}
 	const bodyEntries = [];
 	for (const rp of resolvedParams) {
 		const paramName = propertyName(rp.paramName);
@@ -18301,6 +18376,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.
@@ -18431,9 +18552,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);
@@ -18544,9 +18665,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;
@@ -18666,14 +18786,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) => {
 		if (seenParamDocs.has(name)) return;
 		seenParamDocs.add(name);
-		paramDocs.push(formatParamDoc(name, description, deprecated));
+		paramDocs.push(formatParamDoc(name, description, deprecated, sourceName));
 	};
-	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);
+	for (const qp of queryParams) pushParamDoc(propertyName(qp.name), qp.name, qp.description, qp.deprecated);
+	for (const bf of bodyFields) pushParamDoc(bodyParamNames.get(bf.name), bf.name, bf.description, bf.deprecated);
+	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 +18808,17 @@ 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) {
+	const specText = (description?.split("\n").find((l) => l.trim()) ?? "").trim();
+	const deprecationNote = deprecated ? "**Deprecated.**" : "";
+	const fallback = `the ${humanize(sourceName ?? kotlinName)} of the request.`;
+	return `@param ${kotlinName} ${escapeKdoc([deprecationNote, specText || fallback].filter(Boolean).join(" "))}`;
 }
 /**
 * Unwrap a possibly-nullable type to check if the inner type is an array,
@@ -18709,32 +18837,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) return [`${indent}params.addEach(${ktLiteral(p.name)}, ${prop}.map { ${itemExpr} })`];
-		return [`${indent}${prop}?.let { params.addEach(${ktLiteral(p.name)}, it.map { ${itemExpr} }) }`];
+		if (p.required) {
+			const arg = isIdentity ? prop : `${prop}.map { ${itemExpr} }`;
+			return [`${indent}${callPrefix}addEach(${ktLiteral(p.name)}, ${arg})`];
+		}
+		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) {
@@ -18848,14 +18987,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 +19021,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 {
@@ -18986,6 +19126,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 +19287,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 +19311,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 +19433,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);
 	}
@@ -22300,4 +22469,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-CeNME04k.mjs.map