@kizunajs/kotlin 2.0.0-beta.0

package/dist/generator-BvNpSarY.mjs

@@ -0,0 +1,1795 @@
+import { createGenerator, isDiscriminatedUnionSchema, isFileSchema, isHintPrefix, isIntegerSchema, isNamedStream, isObjectSchema, isStreamResponse, isSuccessStatus, localTypeName, mergeHeaderFields, parsePath, readDef, readDefType, readDeprecation, readDiscriminatedUnion, readDiscriminatorStringLiteral, readMetaDescription, readMetaId, readObjectShape, resolveResponseBody, resolveResponseHeaders, routeStreams, sanitizeFieldName, sanitizeIdentifier, shortTypeName, soleStreamResponse, statusToCamelCase, streamMode, toCamelCase, toPascalCase, unwrapOptionalWrappers } from "kizunajs/generator";
+//#region src/emit.ts
+var KotlinWriter = class {
+	lines = [];
+	depth = 0;
+	line(text = "") {
+		if (text === "") {
+			this.lines.push("");
+			return;
+		}
+		this.lines.push("    ".repeat(this.depth) + text);
+	}
+	block(opener, body) {
+		this.line(`${opener} {`);
+		this.depth += 1;
+		body();
+		this.depth -= 1;
+		this.line("}");
+	}
+	indent(body) {
+		this.depth += 1;
+		body();
+		this.depth -= 1;
+	}
+	docComment(text) {
+		if (!text) return;
+		const segments = text.split("\n");
+		if (segments.length === 1) {
+			this.line(`/** ${segments[0]} */`);
+			return;
+		}
+		this.line("/**");
+		for (const segment of segments) this.line(` * ${segment}`);
+		this.line(" */");
+	}
+	blank() {
+		if (this.lines.length === 0) return;
+		if (this.lines[this.lines.length - 1] === "") return;
+		this.lines.push("");
+	}
+	appendToLastLine(suffix) {
+		if (this.lines.length > 0) this.lines[this.lines.length - 1] += suffix;
+	}
+	toString() {
+		return this.lines.join("\n").replace(/\n+$/, "") + "\n";
+	}
+};
+const stringLiteral = (value) => {
+	return "\"" + value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"";
+};
+//#endregion
+//#region src/zod-to-kotlin.ts
+var TypeRegistry = class {
+	types = /* @__PURE__ */ new Map();
+	warningSet = /* @__PURE__ */ new Set();
+	explicitIds = /* @__PURE__ */ new Set();
+	sealedVariantPayloads = /* @__PURE__ */ new Set();
+	sealedVariantPaths = /* @__PURE__ */ new Map();
+	usesJsonElement = false;
+	constructor(camelCaseProperties = false, unknownEnumCase = false) {
+		this.camelCaseProperties = camelCaseProperties;
+		this.unknownEnumCase = unknownEnumCase;
+	}
+	has(name) {
+		return this.types.has(name);
+	}
+	get(name) {
+		return this.types.get(name);
+	}
+	add(type) {
+		if (this.types.has(type.name)) return;
+		this.types.set(type.name, type);
+	}
+	replace(type) {
+		this.types.set(type.name, type);
+	}
+	all() {
+		return Array.from(this.types.values());
+	}
+	markExplicitId(name) {
+		this.explicitIds.add(name);
+	}
+	isExplicitId(name) {
+		return this.explicitIds.has(name);
+	}
+	markSealedVariantPayload(name) {
+		this.sealedVariantPayloads.add(name);
+	}
+	isSealedVariantPayload(name) {
+		return this.sealedVariantPayloads.has(name);
+	}
+	/**
+	* An inlined sealed variant has no class of its own, so references to it go through the sealed
+	* interface: `UserSessionEvent.Logout`.
+	*/
+	markSealedVariantPath(name, path) {
+		this.sealedVariantPaths.set(name, path);
+	}
+	sealedVariantPath(name) {
+		return this.sealedVariantPaths.get(name);
+	}
+	warnJsonElement(hint, reason) {
+		this.usesJsonElement = true;
+		this.warningSet.add(`${hint}: ${reason}`);
+	}
+	warnings() {
+		return Array.from(this.warningSet);
+	}
+};
+/**
+* The Kotlin property name for a wire key: verbatim, or camelCased under
+* `camelCaseProperties`.
+*/
+const propertyName = (key, camelCase) => {
+	if (!camelCase) return sanitizeFieldName(key);
+	const camel = toCamelCase(key);
+	if (!camel) return "field";
+	return /^[0-9]/.test(camel) ? `_${camel}` : camel;
+};
+const objectFields = (schema, registry, hint) => {
+	const shape = readObjectShape(schema) ?? {};
+	const fields = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(shape)) {
+		const result = mapType(value, registry, `${hint}${toPascalCase(key)}`);
+		const deprecation = readDeprecation(value);
+		const kotlinName = propertyName(key, registry.camelCaseProperties);
+		const previousWireName = seen.get(kotlinName);
+		if (previousWireName !== void 0 && previousWireName !== key) throw new Error(`@kizunajs/kotlin: field key collision in ${hint}, ${stringify(previousWireName)} and ${stringify(key)} both sanitize to ${stringify(kotlinName)}.`);
+		seen.set(kotlinName, key);
+		fields.push({
+			name: kotlinName,
+			wireName: key,
+			type: result.expression,
+			optional: result.optional,
+			description: readMetaDescription(value),
+			isFile: result.isFile,
+			deprecated: deprecation !== void 0,
+			deprecationMessage: deprecation?.message
+		});
+	}
+	return fields;
+};
+const stringify = (value) => JSON.stringify(value);
+const mapType = (schema, registry, hint) => {
+	if (isFileSchema(schema)) return {
+		expression: "MultipartFile",
+		optional: false,
+		isFile: true
+	};
+	const id = readMetaId(schema);
+	const def = readDef(schema);
+	const discriminated = readDiscriminatedUnion(schema);
+	if (discriminated) {
+		const enumName = id ?? sanitizeIdentifier(toPascalCase(hint));
+		if (id) registry.markExplicitId(enumName);
+		if (!registry.has(enumName)) {
+			registry.add({
+				kind: "sealed-class",
+				name: enumName,
+				discriminator: discriminated.discriminator,
+				variants: [],
+				description: readMetaDescription(schema)
+			});
+			const variants = [];
+			for (const option of discriminated.options) {
+				const variantId = readMetaId(option);
+				const literal = readDiscriminatorStringLiteral(option, discriminated.discriminator);
+				const variantResult = mapType(option, registry, variantId ?? `${enumName}${toPascalCase(literal ?? "Variant")}`);
+				if (literal !== void 0) variants.push({
+					caseName: sanitizeCaseName(literal),
+					literal,
+					payloadType: variantResult.expression,
+					nested: variantId === void 0
+				});
+			}
+			for (const variant of variants) {
+				if (variant.nested) {
+					registry.markSealedVariantPayload(variant.payloadType);
+					registry.markSealedVariantPath(variant.payloadType, `${enumName}.${variant.caseName}`);
+					continue;
+				}
+				const payload = registry.get(variant.payloadType);
+				if (payload?.kind === "data-class") registry.replace({
+					...payload,
+					sealedParent: enumName,
+					serialName: variant.literal,
+					discriminatorWireName: discriminated.discriminator
+				});
+			}
+			registry.replace({
+				kind: "sealed-class",
+				name: enumName,
+				discriminator: discriminated.discriminator,
+				variants,
+				description: readMetaDescription(schema)
+			});
+		}
+		return {
+			expression: enumName,
+			optional: false
+		};
+	}
+	if (id && def.type === "object") {
+		registry.markExplicitId(id);
+		if (!registry.has(id)) {
+			registry.add({
+				kind: "data-class",
+				name: id,
+				fields: [],
+				description: readMetaDescription(schema)
+			});
+			const fields = objectFields(schema, registry, id);
+			registry.replace({
+				kind: "data-class",
+				name: id,
+				fields,
+				description: readMetaDescription(schema)
+			});
+		}
+		return {
+			expression: id,
+			optional: false
+		};
+	}
+	const { inner, optional } = unwrapOptionalWrappers(schema);
+	if (optional) {
+		const innerResult = mapType(inner, registry, hint);
+		return {
+			expression: innerResult.expression.endsWith("?") ? innerResult.expression : `${innerResult.expression}?`,
+			optional: true,
+			isFile: innerResult.isFile
+		};
+	}
+	switch (def.type) {
+		case "void":
+		case "never": return {
+			expression: "Unit",
+			optional: false
+		};
+		case "pipe": {
+			const outType = def.out ? readDefType(def.out) : void 0;
+			if (def.out && outType !== "transform") return mapType(def.out, registry, hint);
+			if (def.in) return mapType(def.in, registry, hint);
+			registry.warnJsonElement(hint, "pipe schema missing resolvable type");
+			return {
+				expression: "JsonElement",
+				optional: false
+			};
+		}
+		case "string": return {
+			expression: def.format === "datetime" || def.checks?.some((check) => check.format === "datetime") ? "Instant" : "String",
+			optional: false
+		};
+		case "number": return {
+			expression: isIntegerSchema(schema) ? "Int" : "Double",
+			optional: false
+		};
+		case "bigint": return {
+			expression: "Long",
+			optional: false
+		};
+		case "boolean": return {
+			expression: "Boolean",
+			optional: false
+		};
+		case "date": return {
+			expression: "Instant",
+			optional: false
+		};
+		case "array": {
+			const element = def.element;
+			if (!element) {
+				registry.warnJsonElement(hint, "array element schema missing");
+				return {
+					expression: "List<JsonElement>",
+					optional: false
+				};
+			}
+			return {
+				expression: `List<${mapType(element, registry, `${hint}Item`).expression.replace(/\?$/, "")}>`,
+				optional: false
+			};
+		}
+		case "object": {
+			const className = sanitizeIdentifier(toPascalCase(hint));
+			if (!registry.has(className)) {
+				registry.add({
+					kind: "data-class",
+					name: className,
+					fields: [],
+					description: readMetaDescription(schema)
+				});
+				const fields = objectFields(schema, registry, className);
+				registry.replace({
+					kind: "data-class",
+					name: className,
+					fields,
+					description: readMetaDescription(schema)
+				});
+			}
+			return {
+				expression: className,
+				optional: false
+			};
+		}
+		case "enum": {
+			const enumName = id ?? sanitizeIdentifier(toPascalCase(hint));
+			if (id) registry.markExplicitId(enumName);
+			const entries = def.entries ?? {};
+			const cases = Object.values(entries);
+			if (!registry.has(enumName)) registry.add({
+				kind: "enum-class",
+				name: enumName,
+				cases,
+				description: readMetaDescription(schema),
+				unknownCase: registry.unknownEnumCase
+			});
+			return {
+				expression: enumName,
+				optional: false
+			};
+		}
+		case "literal": {
+			const values = def.values ?? [];
+			if (values.every((value) => typeof value === "string")) return {
+				expression: "String",
+				optional: false
+			};
+			if (values.every((value) => typeof value === "number")) return {
+				expression: "Double",
+				optional: false
+			};
+			if (values.every((value) => typeof value === "boolean")) return {
+				expression: "Boolean",
+				optional: false
+			};
+			registry.warnJsonElement(hint, "literal of mixed types");
+			return {
+				expression: "JsonElement",
+				optional: false
+			};
+		}
+		case "union": {
+			const options = def.options ?? [];
+			if (options.every((option) => {
+				const optionDef = readDef(option);
+				return optionDef.type === "literal" && (optionDef.values ?? []).every((value) => typeof value === "string");
+			})) return {
+				expression: "String",
+				optional: false
+			};
+			const resolved = options.map((option) => mapType(option, registry, hint)).filter((result) => result !== void 0 && result.expression !== "JsonElement");
+			if (resolved.length === 0) {
+				registry.warnJsonElement(hint, "non-discriminated union");
+				return {
+					expression: "JsonElement",
+					optional: false
+				};
+			}
+			const expressions = resolved.map((result) => result.expression);
+			const unique = [...new Set(expressions)];
+			if (unique.length === 1) return resolved[0];
+			const listPattern = /^List<(.+)>$/;
+			const baseTypes = unique.map((expression) => {
+				const match = listPattern.exec(expression);
+				return match ? match[1] : expression;
+			});
+			if (new Set(baseTypes).size === 1) return {
+				expression: `List<${baseTypes[0]}>`,
+				optional: false
+			};
+			registry.warnJsonElement(hint, "non-discriminated union");
+			return {
+				expression: "JsonElement",
+				optional: false
+			};
+		}
+		case "record": {
+			const valueType = def.valueType;
+			if (valueType) return {
+				expression: `Map<String, ${mapType(valueType, registry, `${hint}Value`).expression.replace(/\?$/, "")}>`,
+				optional: false
+			};
+			registry.warnJsonElement(hint, "record without value schema");
+			return {
+				expression: "Map<String, JsonElement>",
+				optional: false
+			};
+		}
+		case "any":
+		case "unknown":
+			registry.warnJsonElement(hint, `${def.type} schema`);
+			return {
+				expression: "JsonElement",
+				optional: false
+			};
+		default:
+			registry.warnJsonElement(hint, `unhandled schema type: ${def.type ?? "unknown"}`);
+			return {
+				expression: "JsonElement",
+				optional: false
+			};
+	}
+};
+const sanitizeCaseName = (literal) => {
+	const cleaned = literal.replace(/[^a-zA-Z0-9_]/g, "_");
+	if (!cleaned) return "value";
+	if (/^[0-9]/.test(cleaned)) return `_${cleaned}`;
+	return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+};
+const collectObjectFields = (schema, registry, hint) => {
+	return objectFields(schema, registry, hint);
+};
+const objectFieldCount = (schema) => {
+	return Object.keys(readObjectShape(schema) ?? {}).length;
+};
+const objectShapeKeys = (schema, camelCase = false) => {
+	return Object.entries(readObjectShape(schema) ?? {}).map(([key, value]) => ({
+		name: propertyName(key, camelCase),
+		wireName: key,
+		isFile: isFileSchema(value)
+	}));
+};
+//#endregion
+//#region src/generator.ts
+const BODY_FLATTEN_MAX_FIELDS = 6;
+const METHODS_REQUIRING_BODY = new Set([
+	"POST",
+	"PUT",
+	"PATCH"
+]);
+const buildRouteMethod = (routeKey, route, registry, deprecated, deprecationMessage, methodNameOverride) => {
+	const fullJoinedName = routeKey.includes(".") ? routeKey.split(".").map((segment, index) => index === 0 ? segment : toPascalCase(segment)).join("") : routeKey;
+	const methodName = methodNameOverride ?? fullJoinedName;
+	const baseHint = toPascalCase(fullJoinedName);
+	const pathParams = parsePath(route.path).paramNames;
+	const declaredPathParams = route.pathParams ? collectObjectFields(route.pathParams, registry, `${baseHint}Params`) : [];
+	const queryFields = route.query ? collectObjectFields(route.query, registry, `${baseHint}Query`) : [];
+	const headerFields = route.headers ? collectObjectFields(route.headers, registry, `${baseHint}Headers`) : [];
+	const bodyDefType = route.body?._def?.type ?? route.body?.def?.type;
+	let bodyDescriptor;
+	if (route.body && bodyDefType !== "void") {
+		const bodyHint = readMetaId(route.body) ?? `${baseHint}Input`;
+		const isMultipart = route.contentType === "multipart/form-data";
+		if (isDiscriminatedUnionSchema(route.body)) bodyDescriptor = {
+			kind: "union",
+			structName: mapType(route.body, registry, bodyHint).expression,
+			flattened: [],
+			multipartFields: []
+		};
+		else if (isMultipart) {
+			mapType(route.body, registry, bodyHint);
+			bodyDescriptor = {
+				kind: "multipart",
+				flattened: collectObjectFields(route.body, registry, bodyHint),
+				multipartFields: objectShapeKeys(route.body, registry.camelCaseProperties)
+			};
+		} else {
+			const isObject = isObjectSchema(route.body);
+			const fieldCount = isObject ? objectFieldCount(route.body) : 0;
+			if (isObject && fieldCount === 0) bodyDescriptor = {
+				kind: "json-empty",
+				flattened: [],
+				multipartFields: []
+			};
+			else {
+				const useStruct = !isObject || fieldCount > BODY_FLATTEN_MAX_FIELDS;
+				const structName = mapType(route.body, registry, bodyHint).expression;
+				if (useStruct) bodyDescriptor = {
+					kind: "json-struct",
+					structName,
+					flattened: [],
+					multipartFields: []
+				};
+				else bodyDescriptor = {
+					kind: "json-flat",
+					structName,
+					flattened: collectObjectFields(route.body, registry, bodyHint),
+					multipartFields: []
+				};
+			}
+		}
+	}
+	const successResponses = [];
+	const errorCases = [];
+	let stream;
+	for (const [statusKey, responseValue] of Object.entries(route.responses)) {
+		const status = Number(statusKey);
+		const responseHint = `${baseHint}Response${status === 200 ? "" : status}`;
+		if (isStreamResponse(responseValue)) {
+			const mode = streamMode(responseValue);
+			if (mode === "events" && isNamedStream(responseValue.stream)) stream = {
+				status,
+				mode,
+				events: Object.entries(responseValue.stream).map(([name, schema]) => ({
+					name,
+					caseName: toPascalCase(name),
+					type: mapType(schema, registry, `${baseHint}${toPascalCase(name)}`).expression
+				}))
+			};
+			else if (mode === "events") stream = {
+				status,
+				mode,
+				messageType: mapType(responseValue.stream, registry, `${baseHint}Message`).expression
+			};
+			else stream = {
+				status,
+				mode
+			};
+			const headersSchema = resolveResponseHeaders(responseValue);
+			successResponses.push({
+				status,
+				type: stream.messageType ?? "Event",
+				responseHeaders: headersSchema ? collectObjectFields(headersSchema, registry, `${baseHint}ResponseHeaders`) : []
+			});
+			continue;
+		}
+		const typeExpression = mapType(resolveResponseBody(responseValue), registry, responseHint).expression;
+		if (isSuccessStatus(status)) {
+			const headersSchema = resolveResponseHeaders(responseValue);
+			const perStatusHeaderFields = headersSchema ? collectObjectFields(headersSchema, registry, `${baseHint}ResponseHeaders`) : [];
+			successResponses.push({
+				status,
+				type: typeExpression,
+				responseHeaders: perStatusHeaderFields
+			});
+		} else errorCases.push({
+			caseName: statusToCamelCase(status),
+			status,
+			type: typeExpression
+		});
+	}
+	if (route.body || route.query) {
+		const has400 = errorCases.some((candidate) => candidate.status === 400);
+		errorCases.push({
+			caseName: has400 ? "validationError" : statusToCamelCase(400),
+			status: 400,
+			type: "ValidationError"
+		});
+	}
+	successResponses.sort((left, right) => left.status - right.status);
+	const resultHeaderFields = mergeHeaderFields(successResponses.map((entry) => entry.responseHeaders));
+	let successReturnType = "Unit";
+	let successSumClassName;
+	if (route.method !== "HEAD") {
+		const onlySuccess = successResponses[0];
+		if (successResponses.length === 1 && onlySuccess) successReturnType = onlySuccess.type;
+		else if (successResponses.length > 1) {
+			successSumClassName = "Success";
+			successReturnType = successSumClassName;
+		}
+	}
+	const resultWrapperName = successReturnType !== "Unit" ? "Result" : void 0;
+	return {
+		name: methodName,
+		operationName: baseHint,
+		summary: route.summary,
+		description: route.description,
+		deprecated,
+		deprecationMessage,
+		pathParams,
+		declaredPathParams,
+		pathTemplate: route.path,
+		method: route.method,
+		body: bodyDescriptor,
+		query: queryFields,
+		headers: headerFields,
+		resultHeaderFields,
+		resultWrapperName,
+		successResponses,
+		successReturnType,
+		successSumClassName,
+		failureClassName: "Failure",
+		errorCases,
+		stream
+	};
+};
+const kotlinGenerator = createGenerator((options, _api) => {
+	const flatMethods = [];
+	const groupMap = /* @__PURE__ */ new Map();
+	return {
+		processRoute({ routeKey, route, deprecated, deprecationMessage }) {
+			if (routeStreams(route) && soleStreamResponse(route) === void 0) {
+				console.warn(`[kizuna/kotlin] Skipping route "${routeKey}": a streamed status beside another 2xx status is not generated.`);
+				return;
+			}
+			const dotIndex = routeKey.indexOf(".");
+			if (dotIndex !== -1) {
+				const groupKey = routeKey.slice(0, dotIndex);
+				const leafName = routeKey.slice(dotIndex + 1).split(".").map((segment, index) => index === 0 ? segment : toPascalCase(segment)).join("");
+				const methods = groupMap.get(groupKey) ?? [];
+				if (methods.length === 0) groupMap.set(groupKey, methods);
+				methods.push(buildRouteMethod(routeKey, route, options.registry, deprecated, deprecationMessage, leafName));
+			} else flatMethods.push(buildRouteMethod(routeKey, route, options.registry, deprecated, deprecationMessage));
+		},
+		finalize() {
+			const groups = [];
+			for (const [groupKey, methods] of groupMap) groups.push({
+				groupKey,
+				className: `${options.namespaceName}${toPascalCase(groupKey)}Client`,
+				propertyName: groupKey,
+				methods
+			});
+			return {
+				flatMethods,
+				groups
+			};
+		}
+	};
+});
+const KOTLIN_KEYWORDS = new Set([
+	"as",
+	"break",
+	"class",
+	"continue",
+	"do",
+	"else",
+	"false",
+	"for",
+	"fun",
+	"if",
+	"in",
+	"interface",
+	"is",
+	"null",
+	"object",
+	"package",
+	"return",
+	"super",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typealias",
+	"typeof",
+	"val",
+	"var",
+	"when",
+	"while"
+]);
+const escapeKeyword = (name) => {
+	return KOTLIN_KEYWORDS.has(name) ? `\`${name}\`` : name;
+};
+const optionalize = (type, optional) => {
+	if (!optional) return type;
+	return type.endsWith("?") ? type : `${type}?`;
+};
+const KOTLIN_PRIMITIVE_TYPES = new Set([
+	"String",
+	"Int",
+	"Double",
+	"Long",
+	"Boolean",
+	"Instant",
+	"Unit"
+]);
+const resolveType = (typeName, currentOperation, context, scope = "client") => {
+	const { operationTypeMap, namespaceName, clientName, fileLevelTypeNames } = context;
+	const optional = typeName.endsWith("?");
+	const base = optional ? typeName.slice(0, -1) : typeName;
+	if (KOTLIN_PRIMITIVE_TYPES.has(base)) return typeName;
+	if (base.startsWith("List<") && base.endsWith(">")) {
+		const resolved = resolveType(base.slice(5, -1), currentOperation, context, scope);
+		return optional ? `List<${resolved}>?` : `List<${resolved}>`;
+	}
+	if (base.startsWith("Map<String, ") && base.endsWith(">")) {
+		const resolved = resolveType(base.slice(12, -1), currentOperation, context, scope);
+		return optional ? `Map<String, ${resolved}>?` : `Map<String, ${resolved}>`;
+	}
+	if (base === "MultipartFile" || base === "ValidationError" || base === "ValidationIssue") {
+		const qualified = `${clientName}.${base}`;
+		return optional ? `${qualified}?` : qualified;
+	}
+	if (base === "JsonElement") return optional ? `JsonElement?` : `JsonElement`;
+	if (fileLevelTypeNames.has(base)) return optional ? `${base}?` : base;
+	const owningStruct = context.ownedTypeMap.get(base);
+	if (owningStruct !== void 0) {
+		const short = shortTypeName(base, owningStruct);
+		const ownerResolved = resolveType(owningStruct, currentOperation, context, scope).replace(/\?$/, "");
+		return optional ? `${ownerResolved}.${short}?` : `${ownerResolved}.${short}`;
+	}
+	const owningOp = operationTypeMap.get(base);
+	if (owningOp === void 0) return optional ? `${namespaceName}.${base}?` : `${namespaceName}.${base}`;
+	const short = localTypeName(base, owningOp);
+	if (owningOp === currentOperation && scope === "operation-object") return optional ? `${short}?` : short;
+	return optional ? `${clientName}.${owningOp}.${short}?` : `${clientName}.${owningOp}.${short}`;
+};
+const buildOperationTypeMap = (allMethods, registry) => {
+	const operationNames = new Set(allMethods.map((method) => method.operationName));
+	const operationTypeMap = /* @__PURE__ */ new Map();
+	for (const type of registry.all()) {
+		let bestMatch;
+		for (const operationName of operationNames) if (isHintPrefix(type.name, operationName)) {
+			if (!bestMatch || operationName.length > bestMatch.length) bestMatch = operationName;
+		}
+		if (bestMatch !== void 0) operationTypeMap.set(type.name, bestMatch);
+	}
+	return operationTypeMap;
+};
+const localizeType = (type, operationName, context) => {
+	const shortName = localTypeName(type.name, operationName);
+	if (type.kind === "data-class") return {
+		...type,
+		name: shortName,
+		fields: type.fields.map((field) => ({
+			...field,
+			type: resolveType(field.type, operationName, context, "operation-object")
+		}))
+	};
+	if (type.kind === "enum-class") return {
+		...type,
+		name: shortName
+	};
+	return {
+		...type,
+		name: shortName,
+		variants: type.variants.map((variant) => ({
+			...variant,
+			payloadType: resolveType(variant.payloadType, operationName, context, "operation-object")
+		}))
+	};
+};
+const deprecatedAnnotation = (message) => {
+	if (message === void 0 || message === "") return "@Deprecated(\"Deprecated\")";
+	return `@Deprecated(${stringLiteral(message)})`;
+};
+/**
+* Converts an enum value into a valid Kotlin enum constant name.
+*
+* Uppercases and snake-cases the value, prefixing `_` when it starts with a
+* digit (Kotlin identifiers cannot begin with one). The original value is
+* preserved separately as the `@SerialName` wire value.
+*/
+const enumConstantName = (value) => {
+	const upper = value.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+	return /^[0-9]/.test(upper) ? `_${upper}` : upper;
+};
+const emitEnumClass = (writer, name, cases, unknownCase, description) => {
+	writer.blank();
+	writer.docComment(description);
+	if (!unknownCase) {
+		writer.line("@Serializable");
+		writer.block(`enum class ${name}(override val wireValue: String) : KizunaQueryValue`, () => {
+			for (let index = 0; index < cases.length; index += 1) {
+				const caseName = cases[index];
+				const enumConstant = enumConstantName(caseName);
+				const separator = index < cases.length - 1 ? "," : "";
+				writer.line(`@SerialName(${stringLiteral(caseName)}) ${enumConstant}(${stringLiteral(caseName)})${separator}`);
+			}
+		});
+		return;
+	}
+	writer.line(`@Serializable(with = ${name}.Serializer::class)`);
+	writer.block(`sealed interface ${name} : KizunaQueryValue`, () => {
+		for (const caseName of cases) writer.block(`data object ${enumConstantName(caseName)} : ${name}`, () => {
+			writer.line(`override val wireValue: String = ${stringLiteral(caseName)}`);
+		});
+		writer.line(`data class Unknown(override val wireValue: String) : ${name}`);
+		writer.blank();
+		writer.block("companion object", () => {
+			writer.block(`fun fromWireValue(wireValue: String): ${name} = when (wireValue)`, () => {
+				for (const caseName of cases) writer.line(`${stringLiteral(caseName)} -> ${enumConstantName(caseName)}`);
+				writer.line("else -> Unknown(wireValue)");
+			});
+		});
+		writer.blank();
+		writer.block(`object Serializer : KSerializer<${name}>`, () => {
+			writer.line(`override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(${stringLiteral(name)}, PrimitiveKind.STRING)`);
+			writer.line(`override fun deserialize(decoder: Decoder): ${name} = ${name}.fromWireValue(decoder.decodeString())`);
+			writer.block(`override fun serialize(encoder: Encoder, value: ${name})`, () => {
+				writer.line("encoder.encodeString(value.wireValue)");
+			});
+		});
+	});
+};
+const emitDataClass = (writer, type, ownedTypeMap, ownedTypeLookup, registryName) => {
+	const lookupName = registryName ?? type.name;
+	const baseFields = type.discriminatorWireName ? type.fields.filter((field) => field.wireName !== type.discriminatorWireName) : type.fields;
+	const hasFile = baseFields.some((field) => field.isFile);
+	const resolveOwnedType = (raw) => {
+		const optional = raw.endsWith("?");
+		const stripped = optional ? raw.slice(0, -1) : raw;
+		const isList = stripped.startsWith("List<") && stripped.endsWith(">");
+		const inner = isList ? stripped.slice(5, -1) : stripped;
+		if (ownedTypeMap.get(inner) !== lookupName) return raw;
+		const short = shortTypeName(inner, lookupName);
+		const resolved = isList ? `List<${short}>` : short;
+		return optional ? `${resolved}?` : resolved;
+	};
+	const adjustedFields = baseFields.map((field) => ({
+		...field,
+		type: resolveOwnedType(field.type)
+	}));
+	const needsSerialName = !hasFile && baseFields.some((field) => field.name !== field.wireName || KOTLIN_KEYWORDS.has(field.name));
+	if (type.serialName !== void 0) writer.line(`@SerialName(${stringLiteral(type.serialName)})`);
+	if (!hasFile) writer.line("@Serializable");
+	const params = adjustedFields.map((field) => {
+		const typeExpression = optionalize(field.type, field.optional);
+		const defaultPart = field.optional ? " = null" : "";
+		const serialNameAnnotation = needsSerialName && (field.name !== field.wireName || KOTLIN_KEYWORDS.has(field.name)) ? `@SerialName(${stringLiteral(field.wireName)}) ` : "";
+		return `${field.deprecated ? `${deprecatedAnnotation(field.deprecationMessage)} ` : ""}${serialNameAnnotation}val ${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+	});
+	const hasOwnedTypes = Array.from(ownedTypeMap.entries()).some(([, owner]) => owner === lookupName);
+	if (params.length === 0) writer.line(`data class ${type.name}(private val unused: Unit = Unit)`);
+	else if (params.length === 1) writer.line(`data class ${type.name}(${params[0]})`);
+	else {
+		writer.line(`data class ${type.name}(`);
+		writer.indent(() => {
+			for (let index = 0; index < params.length; index += 1) {
+				const separator = index < params.length - 1 ? "," : "";
+				writer.line(`${params[index]}${separator}`);
+			}
+		});
+		writer.line(")");
+	}
+	if (type.sealedParent !== void 0) writer.appendToLastLine(` : ${type.sealedParent}`);
+	if (hasOwnedTypes) {
+		writer.appendToLastLine(" {");
+		writer.indent(() => {
+			emitOwnedTypes(writer, lookupName, ownedTypeMap, ownedTypeLookup);
+		});
+		writer.line("}");
+	}
+};
+const emitOwnedTypes = (writer, ownerName, ownedTypeMap, ownedTypeLookup, registry) => {
+	for (const [ownedName, owningType] of ownedTypeMap) {
+		if (owningType !== ownerName) continue;
+		const ownedType = ownedTypeLookup.get(ownedName);
+		if (!ownedType) continue;
+		const shortName = shortTypeName(ownedName, ownerName);
+		emitType(writer, {
+			...ownedType,
+			name: shortName
+		}, ownedTypeMap, ownedTypeLookup, ownedName, registry);
+	}
+};
+const relativeOwnedPath = (typeName, ownedTypeMap, enclosingPath, registry) => {
+	const path = ownedTypePath(typeName, ownedTypeMap, registry);
+	const prefix = `${enclosingPath}.`;
+	return path.startsWith(prefix) ? path.slice(prefix.length) : void 0;
+};
+const ownedTypePath = (typeName, ownedTypeMap, registry) => {
+	const sealedPath = registry?.sealedVariantPath(typeName);
+	if (sealedPath !== void 0) return sealedPath;
+	const owningClass = ownedTypeMap.get(typeName);
+	if (owningClass === void 0) return typeName;
+	return `${ownedTypePath(owningClass, ownedTypeMap, registry)}.${shortTypeName(typeName, owningClass)}`;
+};
+const emitSealedClass = (writer, type, registry, ownedTypeMap, ownedTypeLookup) => {
+	writer.line(`@OptIn(ExperimentalSerializationApi::class)`);
+	writer.line(`@JsonClassDiscriminator(${stringLiteral(type.discriminator)})`);
+	writer.line("@Serializable");
+	const nestedVariants = type.variants.filter((variant) => variant.nested);
+	if (nestedVariants.length === 0) {
+		writer.line(`sealed interface ${type.name}`);
+		return;
+	}
+	const payloadFor = (payloadName) => {
+		const found = registry.all().find((candidate) => candidate.name === payloadName) ?? registry.all().find((candidate) => candidate.name.endsWith(payloadName));
+		return found && found.kind === "data-class" ? found : void 0;
+	};
+	const wrapped = nestedVariants.map((variant) => ({
+		variant,
+		payload: payloadFor(variant.payloadType),
+		inlined: (() => {
+			const candidate = registry.all().find((entry) => entry.name === variant.payloadType);
+			return !!candidate && candidate.kind === "data-class" && candidate.fields.length > 0;
+		})()
+	}));
+	const sharedFields = wrapped.length > 0 && wrapped.every(({ payload, inlined }) => payload !== void 0 && !inlined) ? wrapped[0].payload.fields.filter((field) => wrapped.every(({ payload }) => payload.fields.some((other) => other.name === field.name && other.type === field.type && other.optional === field.optional))) : [];
+	writer.block(`sealed interface ${type.name}`, () => {
+		for (const field of sharedFields) {
+			const typeExpression = optionalize(ownedTypePath(field.type, ownedTypeMap, registry), field.optional);
+			writer.line(`val ${escapeKeyword(field.name)}: ${typeExpression}`);
+		}
+		if (sharedFields.length > 0) writer.blank();
+		for (const variant of nestedVariants) {
+			const payloadType = registry.all().find((candidate) => candidate.name === variant.payloadType);
+			writer.line(`@SerialName(${stringLiteral(variant.literal)})`);
+			writer.line("@Serializable");
+			const ownsNestedTypes = Array.from(ownedTypeMap.values()).includes(variant.payloadType);
+			const emitVariantBody = () => {
+				emitOwnedTypes(writer, variant.payloadType, ownedTypeMap, ownedTypeLookup, registry);
+			};
+			if (payloadType && payloadType.kind === "data-class" && payloadType.fields.length > 0) {
+				const fields = payloadType.fields.filter((field) => field.wireName !== type.discriminator);
+				if (fields.length === 0) writer.line(`data object ${variant.caseName} : ${type.name}`);
+				else {
+					const params = fields.map((field) => {
+						const variantPath = registry.sealedVariantPath(variant.payloadType) ?? variant.payloadType;
+						const typeExpression = optionalize(relativeOwnedPath(field.type, ownedTypeMap, variantPath, registry) ?? ownedTypePath(field.type, ownedTypeMap, registry), field.optional);
+						const defaultPart = field.optional ? " = null" : "";
+						return `val ${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+					});
+					if (params.length === 1) writer.line(`data class ${variant.caseName}(${params[0]}) : ${type.name}`);
+					else {
+						writer.line(`data class ${variant.caseName}(`);
+						writer.indent(() => {
+							for (let index = 0; index < params.length; index += 1) {
+								const separator = index < params.length - 1 ? "," : "";
+								writer.line(`${params[index]}${separator}`);
+							}
+						});
+						writer.line(`) : ${type.name}`);
+					}
+					if (ownsNestedTypes) {
+						writer.appendToLastLine(" {");
+						writer.indent(emitVariantBody);
+						writer.line("}");
+					}
+				}
+			} else if (sharedFields.length > 0) writer.block(`data class ${variant.caseName}(val value: ${ownedTypePath(variant.payloadType, ownedTypeMap, registry)}) : ${type.name}`, () => {
+				for (const field of sharedFields) {
+					const typeExpression = optionalize(ownedTypePath(field.type, ownedTypeMap, registry), field.optional);
+					writer.line(`override val ${escapeKeyword(field.name)}: ${typeExpression} get() = value.${escapeKeyword(field.name)}`);
+				}
+			});
+			else writer.line(`data class ${variant.caseName}(val value: ${ownedTypePath(variant.payloadType, ownedTypeMap, registry)}) : ${type.name}`);
+		}
+	});
+};
+const emitType = (writer, type, ownedTypeMap = /* @__PURE__ */ new Map(), ownedTypeLookup = /* @__PURE__ */ new Map(), registryName, registry) => {
+	writer.blank();
+	writer.docComment(type.description);
+	if (type.kind === "data-class") emitDataClass(writer, type, ownedTypeMap, ownedTypeLookup, registryName);
+	else if (type.kind === "enum-class") emitEnumClass(writer, type.name, type.cases, type.unknownCase, type.description);
+	else if (registry) emitSealedClass(writer, type, registry, ownedTypeMap, ownedTypeLookup);
+};
+const emitTypes = (writer, types, ownedTypeMap = /* @__PURE__ */ new Map(), ownedTypeLookup = /* @__PURE__ */ new Map(), registry) => {
+	for (const type of types) emitType(writer, type, ownedTypeMap, ownedTypeLookup, void 0, registry);
+};
+const emitConstructorClass = (writer, declaration, params) => {
+	if (params.length === 1) writer.line(`${declaration}(${params[0]})`);
+	else {
+		writer.line(`${declaration}(`);
+		writer.indent(() => {
+			for (let index = 0; index < params.length; index += 1) {
+				const separator = index < params.length - 1 ? "," : "";
+				writer.line(`${params[index]}${separator}`);
+			}
+		});
+		writer.line(")");
+	}
+};
+const emitByteArrayEquality = (writer, typeName, fields) => {
+	const equalsTerms = fields.map((field) => {
+		const name = escapeKeyword(field.name);
+		return field.isByteArray ? `${name}.contentEquals(other.${name})` : `${name} == other.${name}`;
+	});
+	writer.line(`override fun equals(other: Any?) = other is ${typeName} && ${equalsTerms.join(" && ")}`);
+	const hashExpression = fields.reduce((accumulator, field, index) => {
+		const name = escapeKeyword(field.name);
+		const term = field.isByteArray ? `${name}.contentHashCode()` : `${name}.hashCode()`;
+		if (index === 0) return term;
+		return `31 * ${index === 1 ? accumulator : `(${accumulator})`} + ${term}`;
+	}, "");
+	writer.line(`override fun hashCode() = ${hashExpression}`);
+};
+const isVoidSuccessMethod = (method) => method.successReturnType === "Unit";
+/**
+* Emit the per-operation result types for the throw-on-error model:
+*
+*   - `Result`: returned on success, exposing `body` (and `headers`). Omitted for
+*     void-success routes, which return `Unit`.
+*   - `Success`: a sealed sum of the success statuses, used as `Result.body` when a
+*     route has more than one success status.
+*   - `Failure`: a sealed `Exception` thrown for declared error statuses, decode
+*     failures, and any unexpected status.
+*/
+const emitOperationResultTypes = (writer, method, context) => {
+	const hasHeaders = method.resultHeaderFields.length > 0;
+	const isMultiSuccess = method.successResponses.length > 1;
+	const isVoidSuccess = isVoidSuccessMethod(method);
+	if (isMultiSuccess) {
+		writer.blank();
+		writer.block("sealed interface Success", () => {
+			for (const successResponse of method.successResponses) {
+				const resolved = resolveType(successResponse.type, method.operationName, context, "operation-object");
+				writer.line(`data class Status${successResponse.status}(val body: ${resolved}) : Success`);
+			}
+		});
+	}
+	const streamEvents = method.stream?.events;
+	if (streamEvents) {
+		const eventNames = new Set(streamEvents.map((event) => event.name));
+		if (eventNames.has("tool_call") && eventNames.has("tool_result")) {
+			writer.blank();
+			writer.line("/** One tool call, with its result once it answered. */");
+			writer.line("data class ToolCallRecord(");
+			writer.indent(() => {
+				writer.line("val id: String,");
+				writer.line("val name: String,");
+				writer.line("val state: State = State.Running,");
+				writer.line("/** The call as it arrived, to read its input. */");
+				writer.line("val call: ToolCall? = null,");
+				writer.line("/** The result once it answered, to read its output. */");
+				writer.line("val result: ToolResult? = null,");
+				writer.line("/** What the tool reported when it failed. */");
+				writer.line("val message: String? = null,");
+			});
+			writer.line(") {");
+			writer.indent(() => {
+				writer.line("/** How far along the call is. */");
+				writer.line("enum class State { Running, Done, Failed }");
+			});
+			writer.line("}");
+			writer.blank();
+			writer.line("/** Fold a stream's events into one row per tool call, in the order the calls arrived. */");
+			writer.block("fun readToolCalls(events: List<Event>): List<ToolCallRecord>", () => {
+				writer.line("val calls = LinkedHashMap<String, ToolCallRecord>()");
+				writer.block("for (event in events)", () => {
+					writer.line("when (event) {");
+					writer.indent(() => {
+						writer.line("is Event.ToolCall -> calls[event.data.id] = (calls[event.data.id] ?: ToolCallRecord(event.data.id, event.data.name)).copy(call = event.data)");
+						writer.line("is Event.ToolResult -> calls[event.data.id] = (calls[event.data.id] ?: ToolCallRecord(event.data.id, event.data.name)).copy(state = ToolCallRecord.State.Done, result = event.data)");
+						if (eventNames.has("tool_error")) writer.line("is Event.ToolError -> calls[event.data.id] = (calls[event.data.id] ?: ToolCallRecord(event.data.id, event.data.name.wireValue)).copy(state = ToolCallRecord.State.Failed, message = event.data.message)");
+						writer.line("else -> Unit");
+					});
+					writer.line("}");
+				});
+				writer.line("return calls.values.toList()");
+			});
+		}
+		writer.blank();
+		writer.block("sealed interface Event", () => {
+			for (const event of streamEvents) {
+				const payloadType = resolveType(event.type, method.operationName, context);
+				writer.line(`data class ${event.caseName}(val data: ${payloadType}) : Event`);
+			}
+		});
+	}
+	if (!isVoidSuccess) {
+		const bodyType = method.stream ? `Flow<${streamElementType(method, context, "operation-object")}>` : isMultiSuccess ? "Success" : resolveType(method.successReturnType, method.operationName, context, "operation-object");
+		writer.blank();
+		const params = [`val body: ${bodyType}`];
+		if (hasHeaders) params.push("val headers: Headers");
+		emitConstructorClass(writer, "data class Result", params);
+		if (hasHeaders) {
+			const headerParams = method.resultHeaderFields.map((field) => {
+				const rawType = resolveType(field.type, method.operationName, context, "operation-object");
+				return `val ${escapeKeyword(field.name)}: ${optionalize(rawType, field.optional)}`;
+			});
+			writer.appendToLastLine(" {");
+			writer.indent(() => {
+				writer.blank();
+				emitConstructorClass(writer, "data class Headers", headerParams);
+			});
+			writer.line("}");
+		}
+	}
+	writer.blank();
+	writer.block("sealed class Failure(message: String? = null) : Exception(message)", () => {
+		for (const errorCase of method.errorCases) {
+			const caseName = toPascalCase(errorCase.caseName);
+			if (errorCase.type === "Unit") writer.line(`data object ${caseName} : Failure()`);
+			else {
+				const resolved = resolveType(errorCase.type, method.operationName, context, "operation-object");
+				writer.line(`data class ${caseName}(val body: ${resolved}) : Failure()`);
+			}
+		}
+		writer.line("class Unexpected(val statusCode: Int, val data: ByteArray) : Failure(\"Unexpected status $statusCode\")");
+		writer.line("class Decoding(override val cause: Throwable, val statusCode: Int, val data: ByteArray) : Failure(cause.message)");
+	});
+};
+const streamElementType = (method, context, scope) => {
+	const stream = method.stream;
+	if (stream.mode === "text") return "String";
+	if (stream.mode === "binary") return "ByteArray";
+	if (stream.events) return scope === "operation-object" ? "Event" : `${context.clientName}.${method.operationName}.Event`;
+	return resolveType(stream.messageType, method.operationName, context, scope);
+};
+const groupTypeRef = (operationName, className, context) => `${context.clientName}.${operationName}.${className}`;
+const groupMemberAccessor = (groupLabel, field) => `${groupLabel}.${escapeKeyword(field.name)}`;
+const groupClassField = (field) => {
+	const typeExpression = optionalize(field.type, field.optional);
+	const defaultPart = field.optional ? " = null" : "";
+	return `val ${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+};
+const emitGroupClass = (writer, className, fields, method, context) => {
+	const resolved = fields.map((field) => ({
+		...field,
+		type: resolveType(field.type, method.operationName, context, "operation-object")
+	}));
+	writer.blank();
+	emitConstructorClass(writer, `data class ${className}`, resolved.map((field) => groupClassField(field)));
+};
+const emitBodyGroupClass = (writer, method, context) => {
+	const body = method.body;
+	if (!body || body.kind === "json-empty") return;
+	const operationName = method.operationName;
+	if (body.kind === "json-struct" || body.kind === "union") {
+		const payloadType = resolveType(body.structName, operationName, context, "operation-object");
+		writer.blank();
+		emitConstructorClass(writer, "data class Body", [`val payload: ${payloadType}`]);
+		return;
+	}
+	const resolved = body.flattened.map((field) => ({
+		...field,
+		type: field.type === "MultipartFile" ? `${context.clientName}.MultipartFile` : resolveType(field.type, operationName, context, "operation-object")
+	}));
+	writer.blank();
+	emitConstructorClass(writer, "data class Body", resolved.map((field) => groupClassField(field)));
+};
+const emitRequestGroupClasses = (writer, method, context) => {
+	if (method.pathParams.length > 0) emitGroupClass(writer, "Params", pathParamFields(method), method, context);
+	if (method.query.length > 0) emitGroupClass(writer, "Query", method.query, method, context);
+	if (method.headers.length > 0) emitGroupClass(writer, "Headers", method.headers, method, context);
+	emitBodyGroupClass(writer, method, context);
+	emitArgsScaffolding(writer, method, context);
+};
+const pathParamFields = (method) => method.pathParams.map((name) => {
+	const declared = method.declaredPathParams.find((field) => field.wireName === name);
+	return declared ? {
+		...declared,
+		optional: false
+	} : {
+		name,
+		wireName: name,
+		type: "String",
+		optional: false
+	};
+});
+const hasBodyGroup = (method) => method.body !== void 0 && method.body.kind !== "json-empty";
+const methodChannels = (method) => {
+	const channels = [];
+	if (method.pathParams.length > 0) channels.push({
+		varName: "params",
+		className: "Params",
+		required: true,
+		fields: pathParamFields(method)
+	});
+	if (method.query.length > 0) channels.push({
+		varName: "query",
+		className: "Query",
+		required: method.query.some((field) => !field.optional),
+		fields: method.query
+	});
+	if (method.headers.length > 0) channels.push({
+		varName: "headers",
+		className: "Headers",
+		required: method.headers.some((field) => !field.optional),
+		fields: method.headers
+	});
+	if (hasBodyGroup(method)) {
+		const body = method.body;
+		const fields = body.kind === "json-struct" || body.kind === "union" ? [{
+			name: "payload",
+			wireName: "payload",
+			type: body.structName,
+			optional: false
+		}] : body.flattened;
+		channels.push({
+			varName: "body",
+			className: "Body",
+			required: true,
+			fields
+		});
+	}
+	return channels;
+};
+const resolveChannelFieldType = (field, method, context) => field.type === "MultipartFile" ? `${context.clientName}.MultipartFile` : resolveType(field.type, method.operationName, context, "operation-object");
+/**
+* Emit the call-shape scaffolding for a method's request channels:
+*
+*   - `Args`: the sealed result of the request-builder lambda, holding one value per channel
+*     (nullable when the channel is all-optional).
+*   - `Scope`: the lambda receiver exposing a factory function per channel
+*     (`params(id = "1")`), so call sites need no type names and completion lists the channels.
+*   - `After<Channel>`: typestate steps returned by each factory; later channels chain off them
+*     (`params(...).headers(...)`). Only steps whose remaining channels are all optional implement
+*     `Args`, so omitting a required channel is a compile error, not a runtime one.
+*/
+const emitArgsScaffolding = (writer, method, context) => {
+	const channels = methodChannels(method).map((channel) => ({
+		...channel,
+		fields: channel.fields.map((field) => ({
+			...field,
+			type: resolveChannelFieldType(field, method, context)
+		}))
+	}));
+	if (channels.length === 0) return;
+	const isTerminal = (lastDecidedIndex) => channels.slice(lastDecidedIndex + 1).every((channel) => !channel.required);
+	const transitionsFrom = (lastDecidedIndex) => {
+		const targets = [];
+		for (let target = lastDecidedIndex + 1; target < channels.length; target += 1) if (channels.slice(lastDecidedIndex + 1, target).every((channel) => !channel.required)) targets.push(target);
+		return targets;
+	};
+	const factorySignature = (channel) => channel.fields.map((field) => {
+		const typeExpression = optionalize(field.type, field.optional);
+		const defaultPart = field.optional ? " = null" : "";
+		return `${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+	}).join(", ");
+	const factoryConstruction = (channel) => {
+		const args = channel.fields.map((field) => `${escapeKeyword(field.name)} = ${escapeKeyword(field.name)}`).join(", ");
+		return `${channel.className}(${args})`;
+	};
+	const emitTransition = (fromIndex, toIndex) => {
+		const target = channels[toIndex];
+		const constructorArgs = [];
+		for (let index = 0; index <= toIndex; index += 1) {
+			const channel = channels[index];
+			if (index < toIndex) constructorArgs.push(`${channel.varName} = ${index <= fromIndex ? channel.varName : "null"}`);
+			else constructorArgs.push(`${channel.varName} = ${factoryConstruction(channel)}`);
+		}
+		writer.line(`fun ${escapeKeyword(target.varName)}(${factorySignature(target)}): After${target.className} = After${target.className}(${constructorArgs.join(", ")})`);
+	};
+	writer.blank();
+	writer.block("sealed interface Args", () => {
+		for (const channel of channels) writer.line(`val ${channel.varName}: ${channel.className}${channel.required ? "" : "?"}`);
+	});
+	writer.blank();
+	writer.block("object Scope", () => {
+		for (const target of transitionsFrom(-1)) emitTransition(-1, target);
+	});
+	for (let stateIndex = 0; stateIndex < channels.length; stateIndex += 1) {
+		const stateChannel = channels[stateIndex];
+		const terminal = isTerminal(stateIndex);
+		const constructorParams = [];
+		for (let index = 0; index <= stateIndex; index += 1) {
+			const channel = channels[index];
+			const modifier = terminal ? "override val" : "internal val";
+			constructorParams.push(`${modifier} ${channel.varName}: ${channel.className}${channel.required ? "" : "?"}`);
+		}
+		const declaration = `class After${stateChannel.className} internal constructor(${constructorParams.join(", ")})${terminal ? " : Args" : ""}`;
+		const undecidedOverrides = terminal ? channels.slice(stateIndex + 1) : [];
+		const transitions = transitionsFrom(stateIndex);
+		writer.blank();
+		if (undecidedOverrides.length === 0 && transitions.length === 0) writer.line(declaration);
+		else writer.block(declaration, () => {
+			for (const channel of undecidedOverrides) writer.line(`override val ${channel.varName}: ${channel.className}? get() = null`);
+			for (const target of transitions) emitTransition(stateIndex, target);
+		});
+	}
+};
+const buildMethodParameters = (method, context) => {
+	const channels = methodChannels(method);
+	if (channels.length === 0) return [];
+	const operationRef = `${context.clientName}.${method.operationName}`;
+	return [`build: ${operationRef}.Scope.() -> ${operationRef}.Args${channels.every((channel) => !channel.required) ? ` = { ${escapeKeyword(channels[0].varName)}() }` : ""}`];
+};
+const emitBodyEncoding = (writer, method, context) => {
+	if (!method.body) return;
+	const body = method.body;
+	if (body.kind === "multipart") {
+		writer.line("val multipartBuilder = MultipartBody.Builder().setType(MultipartBody.FORM)");
+		for (const field of body.multipartFields) {
+			const accessor = groupMemberAccessor("body", field);
+			const isFlattenedFile = body.flattened.find((flatField) => flatField.name === field.name)?.isFile === true;
+			if (field.isFile || isFlattenedFile) writer.line(`multipartBuilder.addFormDataPart(${stringLiteral(field.wireName)}, ${accessor}.filename, ${accessor}.data.toRequestBody(${accessor}.mimeType.toMediaType()))`);
+			else writer.line(`multipartBuilder.addFormDataPart(${stringLiteral(field.wireName)}, ${accessor}.toString())`);
+		}
+		writer.line("requestBody = multipartBuilder.build()");
+		return;
+	}
+	if (body.kind === "json-empty") {
+		writer.line("requestBody = \"{}\".toRequestBody(\"application/json\".toMediaType())");
+		return;
+	}
+	if (body.kind === "json-struct" || body.kind === "union") {
+		writer.line("requestBody = json.encodeToString(body.payload).toRequestBody(\"application/json\".toMediaType())");
+		return;
+	}
+	if (body.kind === "json-flat" && body.structName) {
+		const resolved = resolveType(body.structName, method.operationName, context);
+		const args = body.flattened.map((field) => `${field.name} = ${groupMemberAccessor("body", field)}`).join(", ");
+		writer.line(`val payload = ${resolved}(${args})`);
+		writer.line("requestBody = json.encodeToString(payload).toRequestBody(\"application/json\".toMediaType())");
+	}
+};
+const emitMethodBody = (writer, method, context) => {
+	const operationRef = `${context.clientName}.${method.operationName}`;
+	const failureRef = `${operationRef}.Failure`;
+	const hasBody = method.body !== void 0;
+	const isMultiSuccess = method.successResponses.length > 1;
+	const isVoidSuccess = isVoidSuccessMethod(method);
+	const hasHeaders = method.resultHeaderFields.length > 0;
+	const channels = methodChannels(method);
+	if (channels.length > 0) {
+		writer.line(`val args = ${operationRef}.Scope.build()`);
+		for (const channel of channels) {
+			const groupRef = groupTypeRef(method.operationName, channel.className, context);
+			if (channel.required) writer.line(`val ${channel.varName} = args.${channel.varName}`);
+			else writer.line(`val ${channel.varName} = args.${channel.varName} ?: ${groupRef}()`);
+		}
+	}
+	writer.line(`${method.pathParams.length > 0 ? "var" : "val"} path = ${stringLiteral(method.pathTemplate)}`);
+	for (const field of pathParamFields(method)) {
+		const accessor = groupMemberAccessor("params", field);
+		writer.line(`path = path.replace(${stringLiteral(`:${field.name}`)}, Kizuna.encodePathSegment(${accessor}))`);
+	}
+	writer.line("val urlBuilder = Kizuna.resolveUrl(baseUrl, path)");
+	if (method.query.length > 0) for (const field of method.query) {
+		const accessor = groupMemberAccessor("query", field);
+		const appendBlock = (sourceExpression) => {
+			writer.block(`for (stringValue in Kizuna.stringifyQueryValue(${sourceExpression}))`, () => {
+				writer.line(`urlBuilder.addQueryParameter(${stringLiteral(field.wireName)}, stringValue)`);
+			});
+		};
+		if (field.optional) writer.block(`if (${accessor} != null)`, () => {
+			appendBlock(accessor);
+		});
+		else appendBlock(accessor);
+	}
+	if (hasBody) {
+		writer.line("val requestBody: RequestBody");
+		emitBodyEncoding(writer, method, context);
+	}
+	const builderReassigned = context.requestContextFields.length > 0 || method.headers.length > 0;
+	writer.line(`${builderReassigned ? "var" : "val"} requestBuilder = Request.Builder()`);
+	writer.line("    .url(urlBuilder.build())");
+	if (hasBody) writer.line(`    .method(${stringLiteral(method.method)}, requestBody)`);
+	else if (METHODS_REQUIRING_BODY.has(method.method)) writer.line(`    .method(${stringLiteral(method.method)}, ByteArray(0).toRequestBody(null))`);
+	else writer.line(`    .method(${stringLiteral(method.method)}, null)`);
+	if (context.requestContextFields.length > 0) writer.line("for ((name, value) in requestContextHeaders) requestBuilder = requestBuilder.header(name, value)");
+	for (const field of method.headers) {
+		const accessor = groupMemberAccessor("headers", field);
+		const setHeader = (sourceExpression) => {
+			writer.line(`requestBuilder = requestBuilder.header(${stringLiteral(field.wireName)}, Kizuna.stringifyQueryValue(${sourceExpression}).joinToString(", "))`);
+		};
+		if (field.optional) writer.block(`if (${accessor} != null)`, () => {
+			setHeader(accessor);
+		});
+		else setHeader(accessor);
+	}
+	writer.line("requestInterceptor?.invoke(requestBuilder)");
+	writer.line("val httpResponse = Kizuna.execute(client, requestBuilder.build())");
+	if (method.stream) {
+		emitStreamMethodTail(writer, method, context);
+		return;
+	}
+	writer.line(`${isVoidSuccess ? "" : "return "}httpResponse.use {`);
+	writer.indent(() => {
+		writer.line("responseInterceptor?.invoke(requestBuilder.build(), httpResponse)");
+		writer.line("val data = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { httpResponse.body?.bytes() ?: ByteArray(0) }");
+		writer.line("when (val statusCode = httpResponse.code) {");
+		writer.indent(() => {
+			for (const successResponse of method.successResponses) {
+				if (isVoidSuccess) {
+					writer.line(`${successResponse.status} -> {}`);
+					continue;
+				}
+				writer.line(`${successResponse.status} -> {`);
+				writer.indent(() => {
+					const resolved = resolveType(successResponse.type, method.operationName, context);
+					writer.block("try", () => {
+						writer.line(`val payload = json.decodeFromString<${resolved}>(data.decodeToString())`);
+						const bodyExpr = isMultiSuccess ? `${operationRef}.Success.Status${successResponse.status}(payload)` : "payload";
+						if (hasHeaders) {
+							for (const field of successResponse.responseHeaders) writer.line(`val ${escapeKeyword(field.name)} = httpResponse.header(${stringLiteral(field.wireName)})`);
+							const headersArgs = method.resultHeaderFields.map((field) => `${escapeKeyword(field.name)} = ${escapeKeyword(field.name)}`).join(", ");
+							writer.line(`return@use ${operationRef}.Result(body = ${bodyExpr}, headers = ${operationRef}.Result.Headers(${headersArgs}))`);
+						} else writer.line(`return@use ${operationRef}.Result(body = ${bodyExpr})`);
+					});
+					writer.line(`catch (error: Exception) { throw ${failureRef}.Decoding(error, statusCode, data) }`);
+				});
+				writer.line("}");
+			}
+			emitErrorBranches(writer, method, context);
+		});
+		writer.line("}");
+	});
+	writer.line("}");
+};
+const emitErrorBranches = (writer, method, context) => {
+	const failureRef = `${`${context.clientName}.${method.operationName}`}.Failure`;
+	const grouped = /* @__PURE__ */ new Map();
+	for (const errorCase of method.errorCases) {
+		const existing = grouped.get(errorCase.status);
+		if (existing) existing.push(errorCase);
+		else grouped.set(errorCase.status, [errorCase]);
+	}
+	for (const [status, cases] of grouped) {
+		writer.line(`${status} -> {`);
+		writer.indent(() => {
+			if (cases.length === 1) {
+				const errorCase = cases[0];
+				const caseName = toPascalCase(errorCase.caseName);
+				if (errorCase.type === "Unit") writer.line(`throw ${failureRef}.${caseName}`);
+				else {
+					const resolved = resolveType(errorCase.type, method.operationName, context);
+					writer.line("val payload = try {");
+					writer.indent(() => {
+						writer.line(`json.decodeFromString<${resolved}>(data.decodeToString())`);
+					});
+					writer.line(`} catch (error: Exception) { throw ${failureRef}.Decoding(error, statusCode, data) }`);
+					writer.line(`throw ${failureRef}.${caseName}(body = payload)`);
+				}
+			} else {
+				for (const errorCase of cases) {
+					const caseName = toPascalCase(errorCase.caseName);
+					if (errorCase.type === "Unit") writer.line(`throw ${failureRef}.${caseName}`);
+					else {
+						const resolved = resolveType(errorCase.type, method.operationName, context);
+						writer.line(`val ${errorCase.caseName} = try {`);
+						writer.indent(() => {
+							writer.line(`json.decodeFromString<${resolved}>(data.decodeToString())`);
+						});
+						writer.line("} catch (_: Exception) { null }");
+						writer.line(`if (${errorCase.caseName} != null) throw ${failureRef}.${caseName}(body = ${errorCase.caseName})`);
+					}
+				}
+				writer.line(`throw ${failureRef}.Unexpected(statusCode = statusCode, data = data)`);
+			}
+		});
+		writer.line("}");
+	}
+	writer.line(`else -> throw ${failureRef}.Unexpected(statusCode = statusCode, data = data)`);
+};
+const emitStreamMethodTail = (writer, method, context) => {
+	const operationRef = `${context.clientName}.${method.operationName}`;
+	const stream = method.stream;
+	const successResponse = method.successResponses.find((candidate) => candidate.status === stream.status);
+	const hasHeaders = method.resultHeaderFields.length > 0;
+	writer.line("responseInterceptor?.invoke(requestBuilder.build(), httpResponse)");
+	writer.block(`if (httpResponse.code == ${stream.status})`, () => {
+		if (stream.mode === "text") writer.line("val body = Kizuna.lines(httpResponse)");
+		else if (stream.mode === "binary") writer.line("val body = Kizuna.chunks(httpResponse)");
+		else if (stream.events) {
+			const events = stream.events;
+			const elementType = streamElementType(method, context, "client");
+			closure(writer, `val body = Kizuna.events<${elementType}>(httpResponse) { event ->`, () => {
+				writer.block("when (event.event)", () => {
+					for (const event of events) {
+						const payloadType = resolveType(event.type, method.operationName, context);
+						writer.line(`${stringLiteral(event.name)} -> ${elementType}.${event.caseName}(json.decodeFromString<${payloadType}>(event.data))`);
+					}
+					writer.line("else -> null");
+				});
+			});
+		} else {
+			const elementType = streamElementType(method, context, "client");
+			writer.line(`val body = Kizuna.events<${elementType}>(httpResponse) { event -> json.decodeFromString<${elementType}>(event.data) }`);
+		}
+		if (hasHeaders) {
+			for (const field of successResponse.responseHeaders) writer.line(`val ${escapeKeyword(field.name)} = httpResponse.header(${stringLiteral(field.wireName)})`);
+			const headersArgs = method.resultHeaderFields.map((field) => `${escapeKeyword(field.name)} = ${escapeKeyword(field.name)}`).join(", ");
+			writer.line(`return ${operationRef}.Result(body = body, headers = ${operationRef}.Result.Headers(${headersArgs}))`);
+		} else writer.line(`return ${operationRef}.Result(body = body)`);
+	});
+	writer.line("return httpResponse.use {");
+	writer.indent(() => {
+		writer.line("val data = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { httpResponse.body?.bytes() ?: ByteArray(0) }");
+		writer.line("when (val statusCode = httpResponse.code) {");
+		writer.indent(() => {
+			emitErrorBranches(writer, method, context);
+		});
+		writer.line("}");
+	});
+	writer.line("}");
+};
+const resultRef = (method, context) => `${context.clientName}.${method.operationName}.Result`;
+const buildMethodSignature = (method, context) => {
+	const params = buildMethodParameters(method, context);
+	const returnType = isVoidSuccessMethod(method) ? "" : `: ${resultRef(method, context)}`;
+	return `suspend fun ${escapeKeyword(method.name)}(${params.join(", ")})${returnType}`;
+};
+const emitMethodDoc = (writer, method) => {
+	writer.docComment(method.summary ?? method.description);
+};
+const emitMethod = (writer, method, context) => {
+	emitMethodDoc(writer, method);
+	if (method.deprecated) writer.line(deprecatedAnnotation(method.deprecationMessage));
+	writer.line(`@Throws(${context.clientName}.${method.operationName}.Failure::class)`);
+	writer.block(buildMethodSignature(method, context), () => {
+		emitMethodBody(writer, method, context);
+	});
+};
+const emitSubClientMethod = (writer, method, context) => {
+	emitMethodDoc(writer, method);
+	if (method.deprecated) writer.line(deprecatedAnnotation(method.deprecationMessage));
+	writer.line(`@Throws(${context.clientName}.${method.operationName}.Failure::class)`);
+	writer.block(buildMethodSignature(method, context), () => {
+		emitMethodBody(writer, method, context);
+	});
+};
+const emitSubClientClass = (writer, group, clientName, context) => {
+	writer.blank();
+	writer.block(`class ${group.className}(private val client: OkHttpClient, private val baseUrl: String, private val json: Json, private val requestContextHeaders: Map<String, String>, private val requestInterceptor: (suspend (Request.Builder) -> Unit)?, private val responseInterceptor: (suspend (Request, Response) -> Unit)?)`, () => {
+		for (const method of group.methods) {
+			writer.blank();
+			emitSubClientMethod(writer, method, context);
+		}
+	});
+};
+const closure = (writer, opener, body) => {
+	writer.line(opener);
+	writer.indent(body);
+	writer.line("}");
+};
+const emitKizunaStreaming = (writer) => {
+	writer.blank();
+	writer.line("data class ServerSentEvent(val event: String?, val data: String, val id: String?, val retry: Int?)");
+	writer.blank();
+	writer.block("private suspend fun readLine(source: okio.BufferedSource): String?", () => {
+		writer.line("return kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { source.readUtf8Line() }");
+	});
+	writer.blank();
+	writer.block("fun lines(response: Response): Flow<String> = flow", () => {
+		closure(writer, "response.use { open ->", () => {
+			writer.line("val source = open.body?.source() ?: return@use");
+			writer.block("while (true)", () => {
+				writer.line("val line = readLine(source) ?: break");
+				writer.line("emit(line)");
+			});
+		});
+	});
+	writer.blank();
+	writer.block("fun chunks(response: Response): Flow<ByteArray> = flow", () => {
+		closure(writer, "response.use { open ->", () => {
+			writer.line("val source = open.body?.source() ?: return@use");
+			writer.line("val buffer = ByteArray(16_384)");
+			writer.block("while (true)", () => {
+				writer.line("val read = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { source.read(buffer) }");
+				writer.line("if (read == -1) break");
+				writer.line("emit(buffer.copyOf(read))");
+			});
+		});
+	});
+	writer.blank();
+	writer.block("fun serverSentEvents(response: Response): Flow<ServerSentEvent> = flow", () => {
+		closure(writer, "response.use { open ->", () => {
+			writer.line("val source = open.body?.source() ?: return@use");
+			writer.line("var eventType = \"\"");
+			writer.line("val dataLines = mutableListOf<String>()");
+			writer.line("var lastEventId = \"\"");
+			writer.line("var retry: Int? = null");
+			writer.block("while (true)", () => {
+				writer.line("val line = readLine(source) ?: break");
+				writer.block("if (line.isEmpty())", () => {
+					writer.block("if (dataLines.isNotEmpty())", () => {
+						writer.line("emit(ServerSentEvent(eventType.ifEmpty { null }, dataLines.joinToString(\"\\n\"), lastEventId.ifEmpty { null }, retry))");
+						writer.line("dataLines.clear()");
+						writer.line("retry = null");
+					});
+					writer.line("eventType = \"\"");
+					writer.line("continue");
+				});
+				writer.line("if (line.startsWith(\":\")) continue");
+				writer.line("val separator = line.indexOf(':')");
+				writer.line("val field = if (separator == -1) line else line.substring(0, separator)");
+				writer.line("val value = (if (separator == -1) \"\" else line.substring(separator + 1)).removePrefix(\" \")");
+				writer.block("when (field)", () => {
+					writer.line("\"event\" -> eventType = value");
+					writer.line("\"data\" -> dataLines.add(value)");
+					writer.line("\"id\" -> if (!value.contains('\\u0000')) lastEventId = value");
+					writer.line("\"retry\" -> if (value.isNotEmpty() && value.all { it.isDigit() }) retry = value.toIntOrNull()");
+				});
+			});
+		});
+	});
+	writer.blank();
+	writer.line("fun <Event : Any> events(response: Response, decode: (ServerSentEvent) -> Event?): Flow<Event> = serverSentEvents(response).mapNotNull(decode)");
+};
+const emitKizunaObject = (writer, options) => {
+	writer.blank();
+	writer.block("private object Kizuna", () => {
+		if (options.streaming) emitKizunaStreaming(writer);
+		writer.block("fun resolveUrl(baseUrl: String, path: String): HttpUrl.Builder", () => {
+			writer.line("val base = baseUrl.toHttpUrl()");
+			writer.line("val trimmedPath = path.trimStart('/')");
+			writer.line("val basePath = base.encodedPath.trimEnd('/')");
+			writer.line("val fullPath = if (basePath.isEmpty()) \"/$trimmedPath\" else \"$basePath/$trimmedPath\"");
+			writer.line("return base.newBuilder().encodedPath(fullPath)");
+		});
+		writer.blank();
+		writer.block("fun encodePathSegment(value: Any): String", () => {
+			writer.line("val text = stringifyQueryValue(value).firstOrNull() ?: \"\"");
+			writer.line("return java.net.URLEncoder.encode(text, \"UTF-8\").replace(\"+\", \"%20\")");
+		});
+		writer.blank();
+		writer.block("fun stringifyQueryValue(value: Any): List<String>", () => {
+			writer.line("return when (value) {");
+			writer.indent(() => {
+				writer.line("is Instant -> listOf(value.toString())");
+				writer.line("is List<*> -> value.filterNotNull().flatMap { stringifyQueryValue(it) }");
+				writer.line("is KizunaQueryValue -> listOf(value.wireValue)");
+				writer.line("is Enum<*> -> listOf(value.name)");
+				writer.line("else -> listOf(value.toString())");
+			});
+			writer.line("}");
+		});
+		writer.blank();
+		writer.block("suspend fun execute(client: OkHttpClient, request: Request): Response", () => {
+			writer.line("return kotlinx.coroutines.suspendCancellableCoroutine { continuation ->");
+			writer.indent(() => {
+				writer.line("val call = client.newCall(request)");
+				writer.block("continuation.invokeOnCancellation", () => {
+					writer.line("call.cancel()");
+				});
+				writer.block("call.enqueue(object : Callback", () => {
+					writer.block("override fun onFailure(call: Call, e: java.io.IOException)", () => {
+						writer.line("continuation.resumeWith(Result.failure(e))");
+					});
+					writer.block("override fun onResponse(call: Call, response: Response)", () => {
+						writer.line("continuation.resumeWith(Result.success(response))");
+					});
+				});
+				writer.line(")");
+			});
+			writer.line("}");
+		});
+	});
+};
+const emitClient = (writer, config, partition, context, typesByOperation, registry) => {
+	const { clientName } = config;
+	const { flatMethods, groups } = partition;
+	const allMethods = [...flatMethods, ...groups.flatMap((group) => group.methods)];
+	const usesMultipart = allMethods.some((method) => method.body?.kind === "multipart");
+	const contextFields = context.requestContextFields;
+	const contextRequired = contextFields.some((field) => !field.optional);
+	const contextParam = contextFields.length > 0 ? `requestContext: RequestContext${contextRequired ? "" : " = RequestContext()"}, ` : "";
+	writer.blank();
+	writer.block(`class ${clientName}(private val baseUrl: String, ${contextParam}private val client: OkHttpClient = OkHttpClient(), private val json: Json = Json { ignoreUnknownKeys = true }, private val requestInterceptor: (suspend (Request.Builder) -> Unit)? = null, private val responseInterceptor: (suspend (Request, Response) -> Unit)? = null)`, () => {
+		if (contextFields.length > 0) {
+			writer.blank();
+			writer.line("/** Values sent as headers on every request, from the api's request context. */");
+			emitConstructorClass(writer, "data class RequestContext", contextFields.map((field) => `val ${escapeKeyword(field.name)}: ${field.type}${field.optional ? " = null" : ""}`));
+			writer.blank();
+			writer.block("private val requestContextHeaders: Map<String, String> = buildMap", () => {
+				for (const field of contextFields) if (field.optional) writer.line(`if (requestContext.${escapeKeyword(field.name)} != null) put(${stringLiteral(field.wireName)}, requestContext.${escapeKeyword(field.name)}!!)`);
+				else writer.line(`put(${stringLiteral(field.wireName)}, requestContext.${escapeKeyword(field.name)})`);
+			});
+		}
+		if (usesMultipart) {
+			writer.blank();
+			emitConstructorClass(writer, "data class MultipartFile", [
+				"val data: ByteArray",
+				"val filename: String",
+				"val mimeType: String = \"application/octet-stream\""
+			]);
+			writer.appendToLastLine(" {");
+			writer.indent(() => {
+				emitByteArrayEquality(writer, "MultipartFile", [
+					{
+						name: "data",
+						isByteArray: true
+					},
+					{
+						name: "filename",
+						isByteArray: false
+					},
+					{
+						name: "mimeType",
+						isByteArray: false
+					}
+				]);
+			});
+			writer.line("}");
+		}
+		if (allMethods.some((method) => method.errorCases.some((candidate) => candidate.type === "ValidationError"))) {
+			writer.blank();
+			writer.line("@Serializable");
+			emitConstructorClass(writer, "data class ValidationError", [
+				"val type: String",
+				"val title: String",
+				"val status: Int",
+				"val detail: String",
+				"val errors: List<ValidationIssue>"
+			]);
+			writer.blank();
+			writer.line("@Serializable");
+			emitConstructorClass(writer, "data class ValidationIssue", [
+				"val code: String",
+				"val path: List<String>",
+				"val message: String"
+			]);
+		}
+		for (const method of allMethods) {
+			const localTypes = (typesByOperation.get(method.operationName) ?? []).map((type) => localizeType(type, method.operationName, context));
+			writer.blank();
+			writer.block(`object ${method.operationName}`, () => {
+				emitTypes(writer, localTypes, void 0, void 0, registry);
+				emitRequestGroupClasses(writer, method, context);
+				emitOperationResultTypes(writer, method, context);
+			});
+		}
+		if (groups.length > 0) for (const group of groups) {
+			writer.blank();
+			writer.line(`val ${escapeKeyword(group.propertyName)} = ${group.className}(client, baseUrl, json, ${contextFields.length > 0 ? "requestContextHeaders" : "emptyMap()"}, requestInterceptor, responseInterceptor)`);
+		}
+		for (const method of flatMethods) {
+			writer.blank();
+			emitMethod(writer, method, context);
+		}
+	});
+};
+/**
+* Generate a Kotlin API client from a Kizuna api.
+*
+* @param api - What `defineConfig` assembled.
+* @param config - Override the generated names:
+*   - `namespaceName`: the object wrapping shared types.
+*   - `packageName`: optional package declaration for the generated file.
+*/
+const generateKotlinClient = (api, config) => {
+	const { namespaceName, packageName, camelCaseProperties = false, unknownEnumCase = false } = config;
+	const registry = new TypeRegistry(camelCaseProperties, unknownEnumCase);
+	const partition = kotlinGenerator(api, {
+		namespaceName,
+		registry
+	});
+	const allMethods = [...partition.flatMethods, ...partition.groups.flatMap((group) => group.methods)];
+	const operationTypeMap = buildOperationTypeMap(allMethods, registry);
+	const clientName = `${namespaceName}Client`;
+	const writer = new KotlinWriter();
+	writer.line("// Generated by @kizunajs/kotlin. Do not edit by hand.");
+	writer.blank();
+	const suppressions = [
+		...camelCaseProperties ? [] : [
+			"PropertyName",
+			"LocalVariableName",
+			"ConstructorParameterNaming"
+		],
+		"SpellCheckingInspection",
+		"unused",
+		"RedundantVisibilityModifier",
+		"RedundantUnitReturnType"
+	];
+	writer.line(`@file:Suppress(${suppressions.map((name) => `"${name}"`).join(", ")})`);
+	writer.blank();
+	if (packageName) {
+		writer.line(`package ${packageName}`);
+		writer.blank();
+	}
+	writer.line("import kotlinx.serialization.*");
+	writer.line("import kotlinx.serialization.json.*");
+	if (registry.all().some((type) => type.kind === "enum-class" && type.unknownCase)) {
+		writer.line("import kotlinx.serialization.descriptors.*");
+		writer.line("import kotlinx.serialization.encoding.*");
+	}
+	writer.line("import kotlinx.datetime.Instant");
+	const usesStreaming = allMethods.some((method) => method.stream !== void 0);
+	if (usesStreaming) writer.line("import kotlinx.coroutines.flow.*");
+	writer.line("import okhttp3.*");
+	writer.line("import okhttp3.MediaType.Companion.toMediaType");
+	writer.line("import okhttp3.RequestBody.Companion.toRequestBody");
+	writer.line("import okhttp3.HttpUrl.Companion.toHttpUrl");
+	writer.blank();
+	if (registry.all().some((type) => type.kind === "enum-class")) {
+		writer.block("interface KizunaQueryValue", () => {
+			writer.line("val wireValue: String");
+		});
+		writer.blank();
+	}
+	const sharedTypes = [];
+	const typesByOperation = /* @__PURE__ */ new Map();
+	for (const type of registry.all()) {
+		const owningOp = operationTypeMap.get(type.name);
+		if (owningOp !== void 0) {
+			const bucket = typesByOperation.get(owningOp) ?? [];
+			if (bucket.length === 0) typesByOperation.set(owningOp, bucket);
+			bucket.push(type);
+		} else sharedTypes.push(type);
+	}
+	const fileLevelTypeNames = /* @__PURE__ */ new Set();
+	const allClassNames = sharedTypes.filter((type) => type.kind === "data-class").map((type) => type.name);
+	const ownedTypeMap = /* @__PURE__ */ new Map();
+	for (const type of sharedTypes) {
+		if (registry.isExplicitId(type.name)) continue;
+		if (registry.isSealedVariantPayload(type.name)) continue;
+		let bestMatch;
+		for (const className of allClassNames) {
+			if (className === type.name) continue;
+			if (isHintPrefix(type.name, className) && (!bestMatch || className.length > bestMatch.length)) bestMatch = className;
+		}
+		if (bestMatch !== void 0) ownedTypeMap.set(type.name, bestMatch);
+	}
+	const ownedTypeLookup = new Map(sharedTypes.filter((type) => ownedTypeMap.has(type.name)).map((type) => [type.name, type]));
+	const topLevelSharedTypes = sharedTypes.filter((type) => !ownedTypeMap.has(type.name) && !registry.isSealedVariantPayload(type.name));
+	const requestContextFields = [];
+	for (const declaration of Object.values(api.requestContext ?? {})) {
+		const headersSchema = declaration.headers;
+		if (!headersSchema) continue;
+		requestContextFields.push(...collectObjectFields(headersSchema, registry, "RequestContext"));
+	}
+	const context = {
+		namespaceName,
+		clientName,
+		operationTypeMap,
+		fileLevelTypeNames,
+		ownedTypeMap,
+		requestContextFields
+	};
+	writer.block(`object ${namespaceName}`, () => {
+		emitTypes(writer, topLevelSharedTypes, ownedTypeMap, ownedTypeLookup, registry);
+	});
+	emitClient(writer, { clientName }, partition, context, typesByOperation, registry);
+	for (const group of partition.groups) emitSubClientClass(writer, group, clientName, context);
+	emitKizunaObject(writer, { streaming: usesStreaming });
+	for (const warning of registry.warnings()) process.stderr.write(`[kizuna/kotlin] JsonElement fallback at ${warning}\n`);
+	return writer.toString();
+};
+//#endregion
+export { generateKotlinClient as t };