@kizunajs/swift 2.0.0-beta.0

package/dist/generator-v_aUFbbV.cjs

@@ -0,0 +1,2068 @@
+let kizunajs_generator = require("kizunajs/generator");
+//#region src/emit.ts
+var SwiftWriter = 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;
+		for (const segment of text.split("\n")) this.line(`/// ${segment}`);
+	}
+	blank() {
+		if (this.lines.length === 0) return;
+		if (this.lines[this.lines.length - 1] === "") return;
+		this.lines.push("");
+	}
+	toString() {
+		return this.lines.join("\n").replace(/\n+$/, "") + "\n";
+	}
+};
+const stringLiteral = (value) => {
+	return "\"" + value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"";
+};
+//#endregion
+//#region src/zod-to-swift.ts
+var TypeRegistry = class {
+	types = /* @__PURE__ */ new Map();
+	warningSet = /* @__PURE__ */ new Set();
+	explicitIds = /* @__PURE__ */ new Set();
+	unionVariantOwners = /* @__PURE__ */ new Map();
+	usesAnyCodable = 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);
+	}
+	/**
+	* Records that `payloadName` was synthesized as a variant of `unionName`. The real parent, as
+	* opposed to the name-prefix guess the ownership heuristic would otherwise make.
+	*/
+	markUnionVariant(payloadName, unionName) {
+		this.unionVariantOwners.set(payloadName, unionName);
+	}
+	unionVariantOwner(payloadName) {
+		return this.unionVariantOwners.get(payloadName);
+	}
+	warnAnyCodable(hint, reason) {
+		this.usesAnyCodable = true;
+		this.warningSet.add(`${hint}: ${reason}`);
+	}
+	warnings() {
+		return Array.from(this.warningSet);
+	}
+};
+/**
+* The Swift property name for a wire key: verbatim, or camelCased under
+* `camelCaseProperties`.
+*/
+const propertyName = (key, camelCase) => {
+	if (!camelCase) return (0, kizunajs_generator.sanitizeFieldName)(key);
+	const camel = (0, kizunajs_generator.toCamelCase)(key);
+	if (!camel) return "field";
+	return /^[0-9]/.test(camel) ? `_${camel}` : camel;
+};
+const objectFields = (schema, registry, hint) => {
+	const shape = (0, kizunajs_generator.readObjectShape)(schema) ?? {};
+	const fields = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(shape)) {
+		const result = mapType(value, registry, `${hint}${(0, kizunajs_generator.toPascalCase)(key)}`);
+		const deprecation = (0, kizunajs_generator.readDeprecation)(value);
+		const swiftName = propertyName(key, registry.camelCaseProperties);
+		const previousWireName = seen.get(swiftName);
+		if (previousWireName !== void 0 && previousWireName !== key) throw new Error(`@kizunajs/swift: field key collision in ${hint}, ${stringify(previousWireName)} and ${stringify(key)} both sanitize to ${stringify(swiftName)}.`);
+		seen.set(swiftName, key);
+		fields.push({
+			name: swiftName,
+			wireName: key,
+			type: result.expression,
+			optional: result.optional,
+			description: (0, kizunajs_generator.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 ((0, kizunajs_generator.isFileSchema)(schema)) return {
+		expression: "MultipartFile",
+		optional: false,
+		isFile: true
+	};
+	if ((0, kizunajs_generator.isBinarySchema)(schema)) return {
+		expression: "Foundation.Data",
+		optional: false
+	};
+	const id = (0, kizunajs_generator.readMetaId)(schema);
+	const def = (0, kizunajs_generator.readDef)(schema);
+	const discriminated = (0, kizunajs_generator.readDiscriminatedUnion)(schema);
+	if (discriminated) {
+		const enumName = id ?? (0, kizunajs_generator.sanitizeIdentifier)((0, kizunajs_generator.toPascalCase)(hint));
+		if (id) registry.markExplicitId(enumName);
+		if (!registry.has(enumName)) {
+			registry.add({
+				kind: "discriminated-enum",
+				name: enumName,
+				discriminator: discriminated.discriminator,
+				variants: [],
+				description: (0, kizunajs_generator.readMetaDescription)(schema)
+			});
+			const variants = [];
+			for (const option of discriminated.options) {
+				const variantId = (0, kizunajs_generator.readMetaId)(option);
+				const literal = (0, kizunajs_generator.readDiscriminatorStringLiteral)(option, discriminated.discriminator);
+				const variantResult = mapType(option, registry, variantId ?? `${enumName}${(0, kizunajs_generator.toPascalCase)(literal ?? "Variant")}`);
+				if (literal !== void 0) {
+					variants.push({
+						caseName: sanitizeCaseName(literal),
+						literal,
+						payloadType: variantResult.expression,
+						payloadRegistryName: variantResult.expression
+					});
+					if (variantId === void 0) registry.markUnionVariant(variantResult.expression, enumName);
+				}
+			}
+			registry.replace({
+				kind: "discriminated-enum",
+				name: enumName,
+				discriminator: discriminated.discriminator,
+				variants,
+				description: (0, kizunajs_generator.readMetaDescription)(schema)
+			});
+		}
+		return {
+			expression: enumName,
+			optional: false
+		};
+	}
+	if (id && def.type === "object") {
+		registry.markExplicitId(id);
+		if (!registry.has(id)) {
+			registry.add({
+				kind: "struct",
+				name: id,
+				fields: [],
+				description: (0, kizunajs_generator.readMetaDescription)(schema)
+			});
+			const fields = objectFields(schema, registry, id);
+			registry.replace({
+				kind: "struct",
+				name: id,
+				fields,
+				description: (0, kizunajs_generator.readMetaDescription)(schema)
+			});
+		}
+		return {
+			expression: id,
+			optional: false
+		};
+	}
+	const { inner, optional } = (0, kizunajs_generator.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: "Void",
+			optional: false
+		};
+		case "pipe": {
+			const outType = def.out ? (0, kizunajs_generator.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.warnAnyCodable(hint, "pipe schema missing resolvable type");
+			return {
+				expression: "AnyCodable",
+				optional: false
+			};
+		}
+		case "string": return {
+			expression: def.format === "datetime" || def.checks?.some((check) => check.format === "datetime") ? "Date" : "String",
+			optional: false
+		};
+		case "number": return {
+			expression: (0, kizunajs_generator.isIntegerSchema)(schema) ? "Int" : "Double",
+			optional: false
+		};
+		case "bigint": return {
+			expression: "Int64",
+			optional: false
+		};
+		case "boolean": return {
+			expression: "Bool",
+			optional: false
+		};
+		case "date": return {
+			expression: "Date",
+			optional: false
+		};
+		case "array": {
+			const element = def.element;
+			if (!element) {
+				registry.warnAnyCodable(hint, "array element schema missing");
+				return {
+					expression: "[AnyCodable]",
+					optional: false
+				};
+			}
+			return {
+				expression: `[${mapType(element, registry, `${hint}Item`).expression.replace(/\?$/, "")}]`,
+				optional: false
+			};
+		}
+		case "object": {
+			const structName = (0, kizunajs_generator.sanitizeIdentifier)((0, kizunajs_generator.toPascalCase)(hint));
+			if (!registry.has(structName)) {
+				registry.add({
+					kind: "struct",
+					name: structName,
+					fields: [],
+					description: (0, kizunajs_generator.readMetaDescription)(schema)
+				});
+				const fields = objectFields(schema, registry, structName);
+				registry.replace({
+					kind: "struct",
+					name: structName,
+					fields,
+					description: (0, kizunajs_generator.readMetaDescription)(schema)
+				});
+			}
+			return {
+				expression: structName,
+				optional: false
+			};
+		}
+		case "enum": {
+			const enumName = id ?? (0, kizunajs_generator.sanitizeIdentifier)((0, kizunajs_generator.toPascalCase)(hint));
+			if (id) registry.markExplicitId(enumName);
+			const entries = def.entries ?? {};
+			const cases = Object.values(entries);
+			if (!registry.has(enumName)) registry.add({
+				kind: "enum",
+				name: enumName,
+				cases,
+				description: (0, kizunajs_generator.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: "Bool",
+				optional: false
+			};
+			registry.warnAnyCodable(hint, "literal of mixed types");
+			return {
+				expression: "AnyCodable",
+				optional: false
+			};
+		}
+		case "union": {
+			const options = def.options ?? [];
+			if (options.every((option) => {
+				const optionDef = (0, kizunajs_generator.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 !== "AnyCodable");
+			if (resolved.length === 0) {
+				registry.warnAnyCodable(hint, "non-discriminated union");
+				return {
+					expression: "AnyCodable",
+					optional: false
+				};
+			}
+			const expressions = resolved.map((result) => result.expression);
+			const unique = [...new Set(expressions)];
+			if (unique.length === 1) return resolved[0];
+			const arrayPattern = /^\[(.+)\]$/;
+			const baseTypes = unique.map((expression) => {
+				const match = arrayPattern.exec(expression);
+				return match ? match[1] : expression;
+			});
+			if (new Set(baseTypes).size === 1) return {
+				expression: `[${baseTypes[0]}]`,
+				optional: false
+			};
+			registry.warnAnyCodable(hint, "non-discriminated union");
+			return {
+				expression: "AnyCodable",
+				optional: false
+			};
+		}
+		case "record": {
+			const valueType = def.valueType;
+			if (valueType) return {
+				expression: `[String: ${mapType(valueType, registry, `${hint}Value`).expression.replace(/\?$/, "")}]`,
+				optional: false
+			};
+			registry.warnAnyCodable(hint, "record without value schema");
+			return {
+				expression: "[String: AnyCodable]",
+				optional: false
+			};
+		}
+		case "any":
+		case "unknown":
+			registry.warnAnyCodable(hint, `${def.type} schema`);
+			return {
+				expression: "AnyCodable",
+				optional: false
+			};
+		default:
+			registry.warnAnyCodable(hint, `unhandled schema type: ${def.type ?? "unknown"}`);
+			return {
+				expression: "AnyCodable",
+				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).toLowerCase() + cleaned.slice(1);
+};
+const collectObjectFields = (schema, registry, hint) => {
+	return objectFields(schema, registry, hint);
+};
+const objectFieldCount = (schema) => {
+	return Object.keys((0, kizunajs_generator.readObjectShape)(schema) ?? {}).length;
+};
+const objectShapeKeys = (schema, camelCase = false) => {
+	return Object.entries((0, kizunajs_generator.readObjectShape)(schema) ?? {}).map(([key, value]) => ({
+		name: propertyName(key, camelCase),
+		wireName: key,
+		isFile: (0, kizunajs_generator.isFileSchema)(value)
+	}));
+};
+//#endregion
+//#region src/generator.ts
+const buildRouteMethod = (routeKey, route, registry, deprecated, deprecationMessage, methodNameOverride) => {
+	const fullJoinedName = routeKey.includes(".") ? routeKey.split(".").map((segment, index) => index === 0 ? segment : (0, kizunajs_generator.toPascalCase)(segment)).join("") : routeKey;
+	const methodName = methodNameOverride ?? fullJoinedName;
+	const baseHint = (0, kizunajs_generator.toPascalCase)(fullJoinedName);
+	const pathParams = (0, kizunajs_generator.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`) : [];
+	let bodyDescriptor;
+	if (route.body && !(0, kizunajs_generator.isVoidSchema)(route.body)) {
+		const bodyHint = (0, kizunajs_generator.readMetaId)(route.body) ?? `${baseHint}Input`;
+		const isMultipart = route.contentType === "multipart/form-data";
+		if ((0, kizunajs_generator.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 = (0, kizunajs_generator.isObjectSchema)(route.body);
+			const fieldCount = isObject ? objectFieldCount(route.body) : 0;
+			if (isObject && fieldCount === 0) bodyDescriptor = {
+				kind: "json-empty",
+				flattened: [],
+				multipartFields: []
+			};
+			else {
+				const structName = mapType(route.body, registry, bodyHint).expression;
+				if (!isObject) 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 ((0, kizunajs_generator.isStreamResponse)(responseValue)) {
+			const mode = (0, kizunajs_generator.streamMode)(responseValue);
+			if (mode === "events" && (0, kizunajs_generator.isNamedStream)(responseValue.stream)) stream = {
+				status,
+				mode,
+				events: Object.entries(responseValue.stream).map(([name, schema]) => ({
+					name,
+					caseName: sanitizeEnumCaseName(name),
+					type: mapType(schema, registry, `${baseHint}${(0, kizunajs_generator.toPascalCase)(name)}`).expression
+				}))
+			};
+			else if (mode === "events") stream = {
+				status,
+				mode,
+				messageType: mapType(responseValue.stream, registry, `${baseHint}Message`).expression
+			};
+			else stream = {
+				status,
+				mode
+			};
+			const headersSchema = (0, kizunajs_generator.resolveResponseHeaders)(responseValue);
+			successResponses.push({
+				status,
+				type: stream.messageType ?? "Event",
+				responseHeaders: headersSchema ? collectObjectFields(headersSchema, registry, `${baseHint}ResponseHeaders`) : [],
+				isRaw: false,
+				isBinary: false
+			});
+			continue;
+		}
+		const bodySchema = (0, kizunajs_generator.resolveResponseBody)(responseValue);
+		const responseContentType = (0, kizunajs_generator.resolveResponseContentType)(responseValue);
+		const isBinary = (0, kizunajs_generator.isBinarySchema)(bodySchema);
+		const isRaw = isBinary || responseContentType !== void 0 && !(0, kizunajs_generator.isJsonMediaType)(responseContentType);
+		const typeExpression = mapType(bodySchema, registry, responseHint).expression;
+		if ((0, kizunajs_generator.isSuccessStatus)(status)) {
+			const headersSchema = (0, kizunajs_generator.resolveResponseHeaders)(responseValue);
+			const perStatusHeaderFields = headersSchema ? collectObjectFields(headersSchema, registry, `${baseHint}ResponseHeaders`) : [];
+			successResponses.push({
+				status,
+				type: typeExpression,
+				responseHeaders: perStatusHeaderFields,
+				isRaw,
+				isBinary
+			});
+		} else errorCases.push({
+			caseName: (0, kizunajs_generator.statusToCamelCase)(status),
+			status,
+			type: typeExpression,
+			isRaw,
+			isBinary
+		});
+	}
+	if (route.body || route.query) {
+		const has400 = errorCases.some((c) => c.status === 400);
+		errorCases.push({
+			caseName: has400 ? "validationError" : (0, kizunajs_generator.statusToCamelCase)(400),
+			status: 400,
+			type: "ValidationError",
+			isRaw: false,
+			isBinary: false
+		});
+	}
+	successResponses.sort((left, right) => left.status - right.status);
+	const resultHeaderFields = (0, kizunajs_generator.mergeHeaderFields)(successResponses.map((entry) => entry.responseHeaders));
+	let successReturnType = "Void";
+	let successSumEnumName;
+	if (route.method !== "HEAD") {
+		const onlySuccess = successResponses[0];
+		if (successResponses.length === 1 && onlySuccess) successReturnType = onlySuccess.type;
+		else if (successResponses.length > 1) {
+			successSumEnumName = "Success";
+			successReturnType = successSumEnumName;
+		}
+	}
+	const resultWrapperName = successReturnType !== "Void" ? "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,
+		successSumEnumName,
+		failureEnumName: "Failure",
+		errorCases,
+		stream
+	};
+};
+const swiftGenerator = (0, kizunajs_generator.createGenerator)((options, _api) => {
+	const flatMethods = [];
+	const groupMap = /* @__PURE__ */ new Map();
+	return {
+		processRoute({ routeKey, route, deprecated, deprecationMessage }) {
+			if ((0, kizunajs_generator.routeStreams)(route) && (0, kizunajs_generator.soleStreamResponse)(route) === void 0) {
+				console.warn(`[kizuna/swift] 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 : (0, kizunajs_generator.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,
+				structName: `${options.namespaceName}${(0, kizunajs_generator.toPascalCase)(groupKey)}Client`,
+				propertyName: groupKey,
+				methods
+			});
+			return {
+				flatMethods,
+				groups
+			};
+		}
+	};
+});
+const SWIFT_KEYWORDS = new Set([
+	"associatedtype",
+	"class",
+	"deinit",
+	"enum",
+	"extension",
+	"fileprivate",
+	"func",
+	"import",
+	"init",
+	"inout",
+	"internal",
+	"let",
+	"open",
+	"operator",
+	"private",
+	"protocol",
+	"public",
+	"rethrows",
+	"static",
+	"struct",
+	"subscript",
+	"typealias",
+	"var",
+	"break",
+	"case",
+	"continue",
+	"default",
+	"defer",
+	"do",
+	"else",
+	"fallthrough",
+	"for",
+	"guard",
+	"if",
+	"in",
+	"repeat",
+	"return",
+	"switch",
+	"where",
+	"while",
+	"as",
+	"catch",
+	"false",
+	"is",
+	"nil",
+	"super",
+	"self",
+	"Self",
+	"throw",
+	"throws",
+	"true",
+	"try",
+	"Type",
+	"Protocol",
+	"description"
+]);
+const escapeKeyword = (name) => {
+	return SWIFT_KEYWORDS.has(name) ? `\`${name}\`` : name;
+};
+const isValidSwiftIdentifier = (value) => {
+	return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+};
+/**
+* Rewrite an enum value into a valid Swift case name, preserving the original
+* as the rawValue. Already-valid identifiers (e.g. `snake_case`) are kept
+* verbatim; others are camelCased, with a `_` prefix when they start with a
+* digit. Falls back to `_` when nothing identifier-safe remains.
+*/
+const sanitizeEnumCaseName = (value) => {
+	if (isValidSwiftIdentifier(value)) return value;
+	const camel = (0, kizunajs_generator.toCamelCase)(value);
+	if (!camel) return "_";
+	return /^[0-9]/.test(camel) ? `_${camel}` : camel;
+};
+const optionalize = (type, optional) => {
+	if (!optional) return type;
+	return type.endsWith("?") ? type : `${type}?`;
+};
+const emitNamedFactory = (writer, factoryName, fields, buildExpression) => {
+	const build = buildExpression ?? ((args) => `.init(${args})`);
+	if (fields.length === 0) {
+		writer.block(`public static func ${escapeKeyword(factoryName)}() -> Self`, () => {
+			writer.line(build(""));
+		});
+		return;
+	}
+	const params = fields.map((field) => {
+		const typeExpression = optionalize(field.type, field.optional);
+		const defaultPart = field.optional ? " = nil" : "";
+		return `${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+	});
+	const args = fields.map((field) => `${field.name}: ${escapeKeyword(field.name)}`).join(", ");
+	if (params.length === 1) {
+		writer.block(`public static func ${escapeKeyword(factoryName)}(${params[0]}) -> Self`, () => {
+			writer.line(build(args));
+		});
+		return;
+	}
+	writer.line(`public static func ${escapeKeyword(factoryName)}(`);
+	for (let index = 0; index < params.length; index += 1) writer.line(`    ${params[index]}${index === params.length - 1 ? "" : ","}`);
+	writer.block(") -> Self", () => {
+		writer.line(build(args));
+	});
+};
+const emitMemberwiseInit = (writer, fields, assignmentTarget = (field) => escapeKeyword(field.name)) => {
+	if (fields.length === 0) {
+		writer.line("public init() {}");
+		return;
+	}
+	const params = fields.map((field) => {
+		const typeExpression = optionalize(field.type, field.optional);
+		const defaultPart = field.optional ? " = nil" : "";
+		return `${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
+	});
+	if (params.length === 1) {
+		writer.block(`public init(${params[0]})`, () => {
+			for (const field of fields) writer.line(`self.${assignmentTarget(field)} = ${escapeKeyword(field.name)}`);
+		});
+		return;
+	}
+	writer.line("public init(");
+	for (let index = 0; index < params.length; index += 1) {
+		const suffix = index === params.length - 1 ? "" : ",";
+		writer.line(`    ${params[index]}${suffix}`);
+	}
+	writer.block(")", () => {
+		for (const field of fields) writer.line(`self.${assignmentTarget(field)} = ${escapeKeyword(field.name)}`);
+	});
+};
+const deprecatedStorageName = (field, siblings) => {
+	const takenNames = new Set(siblings.map((sibling) => sibling.name));
+	let storageName = `_${field.name}`;
+	while (takenNames.has(storageName)) storageName = `_${storageName}`;
+	return storageName;
+};
+const unknownCaseName = (caseNames) => {
+	const taken = new Set(caseNames);
+	let candidate = "unknown";
+	while (taken.has(candidate)) candidate = `_${candidate}`;
+	return candidate;
+};
+const emitStringEnum = (writer, name, cases, unknownCase, description) => {
+	writer.blank();
+	writer.docComment(description);
+	if (!unknownCase) {
+		writer.block(`public enum ${name}: String, Codable, Sendable`, () => {
+			for (const caseName of cases) writer.line(`case ${escapeKeyword(sanitizeEnumCaseName(caseName))} = ${stringLiteral(caseName)}`);
+		});
+		return;
+	}
+	const caseNames = cases.map((caseName) => sanitizeEnumCaseName(caseName));
+	const unknown = unknownCaseName(caseNames);
+	writer.block(`public enum ${name}: RawRepresentable, Codable, Sendable, Hashable`, () => {
+		for (const caseName of caseNames) writer.line(`case ${escapeKeyword(caseName)}`);
+		writer.line(`case ${escapeKeyword(unknown)}(String)`);
+		writer.blank();
+		writer.block("public init(rawValue: String)", () => {
+			writer.line("switch rawValue {");
+			for (let index = 0; index < cases.length; index += 1) writer.line(`case ${stringLiteral(cases[index])}: self = .${escapeKeyword(caseNames[index])}`);
+			writer.line(`default: self = .${escapeKeyword(unknown)}(rawValue)`);
+			writer.line("}");
+		});
+		writer.blank();
+		writer.block("public var rawValue: String", () => {
+			writer.line("switch self {");
+			for (let index = 0; index < cases.length; index += 1) writer.line(`case .${escapeKeyword(caseNames[index])}: return ${stringLiteral(cases[index])}`);
+			writer.line(`case let .${escapeKeyword(unknown)}(value): return value`);
+			writer.line("}");
+		});
+		writer.blank();
+		writer.block("public init(from decoder: Decoder) throws", () => {
+			writer.line("let container = try decoder.singleValueContainer()");
+			writer.line("self.init(rawValue: try container.decode(String.self))");
+		});
+		writer.blank();
+		writer.block("public func encode(to encoder: Encoder) throws", () => {
+			writer.line("var container = encoder.singleValueContainer()");
+			writer.line("try container.encode(rawValue)");
+		});
+	});
+};
+const ownedTypePath = (typeName, ownedTypeMap) => {
+	const owningStruct = ownedTypeMap.get(typeName);
+	if (owningStruct === void 0) return typeName;
+	return `${ownedTypePath(owningStruct, ownedTypeMap)}.${(0, kizunajs_generator.shortTypeName)(typeName, owningStruct)}`;
+};
+const relativeOwnedPath = (typeName, ownedTypeMap, enclosingName) => {
+	const path = ownedTypePath(typeName, ownedTypeMap);
+	const prefix = `${enclosingName}.`;
+	return path.startsWith(prefix) ? path.slice(prefix.length) : void 0;
+};
+const qualifyOwnedVariants = (type, ownedTypeMap, enclosingName) => ({
+	...type,
+	variants: type.variants.map((variant) => ({
+		...variant,
+		payloadType: relativeOwnedPath(variant.payloadType, ownedTypeMap, enclosingName) ?? ownedTypePath(variant.payloadType, ownedTypeMap)
+	}))
+});
+const emitTypes = (writer, types, context, ownedTypeMap = /* @__PURE__ */ new Map(), ownedTypeLookup = /* @__PURE__ */ new Map()) => {
+	for (const type of types) {
+		writer.blank();
+		writer.docComment(type.description);
+		if (type.kind === "struct") emitStruct(writer, type, context, ownedTypeMap, ownedTypeLookup);
+		else if (type.kind === "enum") emitStringEnum(writer, type.name, type.cases, type.unknownCase, type.description);
+		else emitDiscriminatedEnum(writer, qualifyOwnedVariants(type, ownedTypeMap, type.name), context, type.name, ownedTypeMap, ownedTypeLookup);
+	}
+};
+const emitOwnedTypes = (writer, ownerName, context, ownedTypeMap, ownedTypeLookup) => {
+	for (const [ownedName, owningType] of ownedTypeMap) {
+		if (owningType !== ownerName) continue;
+		const ownedType = ownedTypeLookup.get(ownedName);
+		if (!ownedType) continue;
+		const shortName = (0, kizunajs_generator.shortTypeName)(ownedName, ownerName);
+		if (ownedType.kind === "enum") emitStringEnum(writer, shortName, ownedType.cases, ownedType.unknownCase, ownedType.description);
+		else if (ownedType.kind === "struct") emitStruct(writer, {
+			...ownedType,
+			name: shortName
+		}, context, ownedTypeMap, ownedTypeLookup, ownedName);
+		else if (ownedType.kind === "discriminated-enum") emitDiscriminatedEnum(writer, qualifyOwnedVariants({
+			...ownedType,
+			name: shortName
+		}, ownedTypeMap, ownedName), context, ownedName, ownedTypeMap, ownedTypeLookup);
+	}
+};
+const emitStruct = (writer, type, context, ownedTypeMap, ownedTypeLookup, registryName) => {
+	const lookupName = registryName ?? type.name;
+	const hasFile = type.fields.some((field) => field.isFile);
+	const conformances = hasFile ? "Sendable, Equatable" : "Codable, Sendable, Equatable";
+	const resolveOwnedType = (raw) => {
+		const optional = raw.endsWith("?");
+		const stripped = optional ? raw.slice(0, -1) : raw;
+		const isArray = stripped.startsWith("[") && stripped.endsWith("]");
+		const inner = isArray ? stripped.slice(1, -1) : stripped;
+		if (ownedTypeMap.get(inner) !== lookupName) return raw;
+		const short = (0, kizunajs_generator.shortTypeName)(inner, lookupName);
+		const resolved = isArray ? `[${short}]` : short;
+		return optional ? `${resolved}?` : resolved;
+	};
+	const resolveFieldType = (fieldType, fieldOptional) => {
+		return optionalize(resolveOwnedType(fieldType), fieldOptional);
+	};
+	const adjustedFields = type.fields.map((field) => ({
+		...field,
+		type: resolveOwnedType(field.type)
+	}));
+	const needsCodingKeys = !hasFile && type.fields.some((field) => field.name !== field.wireName || SWIFT_KEYWORDS.has(field.name) || field.deprecated === true);
+	writer.block(`public struct ${type.name}: ${conformances}`, () => {
+		emitOwnedTypes(writer, lookupName, context, ownedTypeMap, ownedTypeLookup);
+		for (const field of type.fields) {
+			const fieldType = resolveFieldType(field.type, field.optional);
+			if (field.deprecated) {
+				writer.line(`private let ${deprecatedStorageName(field, type.fields)}: ${fieldType}`);
+				writer.docComment(field.description);
+				writer.line(deprecatedAttribute(field.deprecationMessage));
+				writer.line(`public var ${escapeKeyword(field.name)}: ${fieldType} { ${deprecatedStorageName(field, type.fields)} }`);
+			} else {
+				writer.docComment(field.description);
+				writer.line(`public let ${escapeKeyword(field.name)}: ${fieldType}`);
+			}
+		}
+		if (needsCodingKeys) {
+			writer.blank();
+			writer.block("private enum CodingKeys: String, CodingKey", () => {
+				for (const field of type.fields) if (field.deprecated) writer.line(`case ${deprecatedStorageName(field, type.fields)} = ${stringLiteral(field.wireName)}`);
+				else if (field.name === field.wireName) writer.line(`case ${escapeKeyword(field.name)}`);
+				else writer.line(`case ${escapeKeyword(field.name)} = ${stringLiteral(field.wireName)}`);
+			});
+		}
+		writer.blank();
+		emitMemberwiseInit(writer, adjustedFields, (field) => field.deprecated ? deprecatedStorageName(field, type.fields) : escapeKeyword(field.name));
+	});
+};
+const emitDiscriminatedEnum = (writer, type, context, registryName, ownedTypeMap, ownedTypeLookup) => {
+	const lookupName = registryName ?? type.name;
+	writer.block(`public enum ${type.name}: Codable, Sendable, Equatable`, () => {
+		if (ownedTypeMap && ownedTypeLookup) emitOwnedTypes(writer, lookupName, context, ownedTypeMap, ownedTypeLookup);
+		for (const variant of type.variants) writer.line(`case ${escapeKeyword(variant.caseName)}(${variant.payloadType})`);
+		for (const variant of type.variants) {
+			const payloadStruct = registryStruct(variant.payloadRegistryName, context);
+			if (!payloadStruct) continue;
+			const isDiscriminator = (field) => field.wireName === type.discriminator || field.name === type.discriminator;
+			const factoryParams = payloadStruct.fields.filter((field) => !isDiscriminator(field)).map((field) => {
+				const defaultPart = field.optional ? " = nil" : "";
+				const fieldType = (ownedTypeMap && relativeOwnedPath(field.type, ownedTypeMap, lookupName)) ?? resolveType(field.type, void 0, context);
+				return `${escapeKeyword(field.name)}: ${optionalize(fieldType, field.optional)}${defaultPart}`;
+			}).join(", ");
+			const payloadArgs = payloadStruct.fields.map((field) => {
+				if (isDiscriminator(field)) {
+					const literal = field.type === "String" ? stringLiteral(variant.literal) : variant.literal;
+					return `${field.name}: ${literal}`;
+				}
+				return `${field.name}: ${escapeKeyword(field.name)}`;
+			}).join(", ");
+			writer.block(`public static func ${escapeKeyword(variant.caseName)}(${factoryParams}) -> ${type.name}`, () => {
+				writer.line(`.${escapeKeyword(variant.caseName)}(${variant.payloadType}(${payloadArgs}))`);
+			});
+		}
+		const variantStructs = type.variants.map((variant) => ({
+			variant,
+			struct: registryStruct(variant.payloadRegistryName, context)
+		}));
+		const firstStruct = variantStructs[0]?.struct;
+		if (firstStruct && variantStructs.every(({ struct }) => struct !== void 0)) {
+			const shared = firstStruct.fields.filter((field) => variantStructs.every(({ struct }) => struct.fields.some((other) => other.name === field.name && other.type === field.type && other.optional === field.optional)));
+			for (const field of shared) {
+				const fieldType = optionalize((ownedTypeMap && relativeOwnedPath(field.type, ownedTypeMap, lookupName)) ?? resolveType(field.type, void 0, context), field.optional);
+				writer.blank();
+				writer.block(`public var ${escapeKeyword(field.name)}: ${fieldType}`, () => {
+					writer.line("switch self {");
+					for (const { variant } of variantStructs) writer.line(`case .${escapeKeyword(variant.caseName)}(let payload): return payload.${escapeKeyword(field.name)}`);
+					writer.line("}");
+				});
+			}
+		}
+		writer.blank();
+		writer.block("private enum DiscriminatorKey: String, CodingKey", () => {
+			writer.line(`case discriminator = ${stringLiteral(type.discriminator)}`);
+		});
+		writer.blank();
+		writer.block("public init(from decoder: Decoder) throws", () => {
+			writer.line("let container = try decoder.container(keyedBy: DiscriminatorKey.self)");
+			writer.line("let kind = try container.decode(String.self, forKey: .discriminator)");
+			writer.line("let single = try decoder.singleValueContainer()");
+			writer.line("switch kind {");
+			for (const variant of type.variants) {
+				writer.line(`case ${stringLiteral(variant.literal)}:`);
+				writer.line(`    self = .${escapeKeyword(variant.caseName)}(try single.decode(${variant.payloadType}.self))`);
+			}
+			writer.line("default:");
+			writer.line("    throw DecodingError.dataCorruptedError(forKey: .discriminator, in: container, debugDescription: \"Unknown discriminator: \\(kind)\")");
+			writer.line("}");
+		});
+		writer.blank();
+		writer.block("public func encode(to encoder: Encoder) throws", () => {
+			writer.line("var single = encoder.singleValueContainer()");
+			writer.line("switch self {");
+			for (const variant of type.variants) {
+				writer.line(`case .${escapeKeyword(variant.caseName)}(let payload):`);
+				writer.line("    try single.encode(payload)");
+			}
+			writer.line("}");
+		});
+	});
+};
+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 ((0, kizunajs_generator.isHintPrefix)(type.name, operationName)) {
+			if (!bestMatch || operationName.length > bestMatch.length) bestMatch = operationName;
+		}
+		if (bestMatch !== void 0) operationTypeMap.set(type.name, bestMatch);
+	}
+	return operationTypeMap;
+};
+const SWIFT_PRIMITIVE_TYPES = new Set([
+	"String",
+	"Int",
+	"Double",
+	"Bool",
+	"Date",
+	"Void",
+	"Foundation.Data"
+]);
+const resolveType = (typeName, currentOperation, context, scope = "actor") => {
+	const { operationTypeMap, namespaceName, clientName, fileLevelTypeNames } = context;
+	const optional = typeName.endsWith("?");
+	const base = optional ? typeName.slice(0, -1) : typeName;
+	if (SWIFT_PRIMITIVE_TYPES.has(base)) return typeName;
+	if (base.startsWith("[") && base.endsWith("]")) {
+		const resolved = resolveType(base.slice(1, -1), currentOperation, context, scope);
+		return optional ? `[${resolved}]?` : `[${resolved}]`;
+	}
+	if (base === "MultipartFile" || base === "ValidationError" || base === "ValidationIssue") {
+		const qualified = `${clientName}.${base}`;
+		return optional ? `${qualified}?` : qualified;
+	}
+	if (base === "AnyCodable") {
+		const qualified = `${clientName}.JSONValue`;
+		return optional ? `${qualified}?` : qualified;
+	}
+	if (fileLevelTypeNames.has(base)) return optional ? `${base}?` : base;
+	const owningStruct = context.ownedTypeMap.get(base);
+	if (owningStruct !== void 0) {
+		const short = (0, kizunajs_generator.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 = (0, kizunajs_generator.localTypeName)(base, owningOp);
+	if (owningOp === currentOperation && scope === "operation-enum") return optional ? `${short}?` : short;
+	return optional ? `${clientName}.${owningOp}.${short}?` : `${clientName}.${owningOp}.${short}`;
+};
+const localizeType = (type, operationName, context) => {
+	const shortName = (0, kizunajs_generator.localTypeName)(type.name, operationName);
+	if (type.kind === "struct") return {
+		...type,
+		name: shortName,
+		fields: type.fields.map((field) => ({
+			...field,
+			type: resolveType(field.type, operationName, context, "operation-enum")
+		}))
+	};
+	if (type.kind === "enum") return {
+		...type,
+		name: shortName
+	};
+	return {
+		...type,
+		name: shortName,
+		variants: type.variants.map((variant) => ({
+			...variant,
+			payloadType: resolveType(variant.payloadType, operationName, context, "operation-enum")
+		}))
+	};
+};
+const streamElementType = (method, context, scope) => {
+	const stream = method.stream;
+	if (stream.mode === "text") return "String";
+	if (stream.mode === "binary") return "Foundation.Data";
+	if (stream.events) return scope === "operation-enum" ? "Event" : `${context.clientName}.${method.operationName}.Event`;
+	return resolveType(stream.messageType, method.operationName, context, scope);
+};
+const emitEventEnum = (writer, method, context) => {
+	const events = method.stream?.events;
+	if (!events) return;
+	writer.blank();
+	writer.block("public enum Event: Sendable, Equatable", () => {
+		for (const event of events) writer.line(`case ${escapeKeyword(event.caseName)}(${resolveType(event.type, method.operationName, context, "operation-enum")})`);
+	});
+};
+/**
+* The per-route call tracker, for a stream that carries tool events. It folds
+* the events into one row per call, keyed by the `id` tying a call to its
+* result, so a view renders a list rather than a switch.
+*/
+const emitToolTracking = (writer, method) => {
+	const events = method.stream?.events;
+	if (!events) return;
+	const names = new Set(events.map((event) => event.name));
+	if (!names.has("tool_call") || !names.has("tool_result")) return;
+	writer.blank();
+	writer.block("public struct ToolCallRecord: Identifiable, Sendable, Equatable", () => {
+		writer.line("/// How far along the call is.");
+		writer.block("public enum State: Sendable, Equatable", () => {
+			writer.line("case running");
+			writer.line("case done");
+			writer.line("case failed");
+		});
+		writer.blank();
+		writer.line("public let id: String");
+		writer.line("public let name: String");
+		writer.line("public var state: State");
+		writer.line("/// The call as it arrived, to read its input.");
+		writer.line("public var call: ToolCall?");
+		writer.line("/// The result once it answered, to read its output.");
+		writer.line("public var result: ToolResult?");
+		writer.line("/// What the tool reported when it failed.");
+		writer.line("public var message: String?");
+	});
+	writer.blank();
+	writer.line("/// Fold a stream's events into one row per tool call, in the order the calls arrived.");
+	writer.block("public static func readToolCalls(_ events: [Event]) -> [ToolCallRecord]", () => {
+		writer.line("var order: [String] = []");
+		writer.line("var calls: [String: ToolCallRecord] = [:]");
+		writer.blank();
+		writer.block("func at(_ id: String, _ name: String) -> ToolCallRecord", () => {
+			writer.line("if let existing = calls[id] { return existing }");
+			writer.line("order.append(id)");
+			writer.line("return ToolCallRecord(id: id, name: name, state: .running, call: nil, result: nil, message: nil)");
+		});
+		writer.blank();
+		writer.block("for event in events", () => {
+			writer.line("switch event {");
+			if (names.has("tool_call")) {
+				writer.line("case .tool_call(let payload):");
+				writer.line("    var tracked = at(payload.id, payload.name)");
+				writer.line("    tracked.call = payload");
+				writer.line("    calls[payload.id] = tracked");
+			}
+			if (names.has("tool_result")) {
+				writer.line("case .tool_result(let payload):");
+				writer.line("    var tracked = at(payload.id, payload.name)");
+				writer.line("    tracked.state = .done");
+				writer.line("    tracked.result = payload");
+				writer.line("    calls[payload.id] = tracked");
+			}
+			if (names.has("tool_error")) {
+				writer.line("case .tool_error(let payload):");
+				writer.line("    var tracked = at(payload.id, payload.name.rawValue)");
+				writer.line("    tracked.state = .failed");
+				writer.line("    tracked.message = payload.message");
+				writer.line("    calls[payload.id] = tracked");
+			}
+			writer.line("default:");
+			writer.line("    continue");
+			writer.line("}");
+		});
+		writer.blank();
+		writer.line("return order.compactMap { calls[$0] }");
+	});
+};
+const emitResultStruct = (writer, method, context) => {
+	if (!method.resultWrapperName) return;
+	writer.blank();
+	writer.block("public struct Result: Sendable", () => {
+		const bodyType = method.stream ? `AsyncThrowingStream<${streamElementType(method, context, "operation-enum")}, Swift.Error>` : method.successSumEnumName ? "Success" : resolveType(method.successReturnType, method.operationName, context, "operation-enum");
+		const hasHeaders = method.resultHeaderFields.length > 0;
+		writer.line(`public let body: ${bodyType}`);
+		if (hasHeaders) {
+			writer.line("public let headers: Headers");
+			writer.blank();
+			writer.block("public struct Headers: Sendable", () => {
+				for (const field of method.resultHeaderFields) {
+					const rawType = resolveType(field.type, method.operationName, context, "operation-enum");
+					writer.line(`public let ${escapeKeyword(field.name)}: ${optionalize(rawType, field.optional)}`);
+				}
+			});
+		}
+		writer.blank();
+		if (hasHeaders) writer.block(`public init(body: ${bodyType}, headers: Headers)`, () => {
+			writer.line("self.body = body");
+			writer.line("self.headers = headers");
+		});
+		else writer.block(`public init(body: ${bodyType})`, () => {
+			writer.line("self.body = body");
+		});
+	});
+};
+const emitGroupStruct = (writer, structName, factoryName, fields, method, context) => {
+	const resolved = fields.map((field) => ({
+		...field,
+		type: resolveType(field.type, method.operationName, context, "operation-enum")
+	}));
+	writer.blank();
+	writer.block(`public struct ${structName}: Sendable`, () => {
+		for (const field of resolved) writer.line(`public let ${escapeKeyword(field.name)}: ${optionalize(field.type, field.optional)}`);
+		writer.blank();
+		emitMemberwiseInit(writer, resolved);
+		writer.blank();
+		emitNamedFactory(writer, factoryName, resolved);
+	});
+};
+const emitBodyType = (writer, method, context) => {
+	const body = method.body;
+	if (!body || body.kind === "json-empty") return;
+	const operationName = method.operationName;
+	writer.blank();
+	if (body.kind === "multipart") {
+		const resolved = body.flattened.map((field) => ({
+			...field,
+			type: resolveType(field.type, operationName, context, "operation-enum")
+		}));
+		writer.block("public struct Body: Sendable", () => {
+			for (const field of resolved) writer.line(`public let ${escapeKeyword(field.name)}: ${optionalize(field.type, field.optional)}`);
+			writer.blank();
+			emitMemberwiseInit(writer, resolved);
+			writer.blank();
+			emitNamedFactory(writer, "body", resolved);
+		});
+		return;
+	}
+	const payloadType = body.structName ? resolveType(body.structName, operationName, context, "operation-enum") : `${context.clientName}.JSONValue`;
+	writer.block("public struct Body: Sendable", () => {
+		writer.line(`public let payload: ${payloadType}`);
+		writer.blank();
+		writer.block(`public init(payload: ${payloadType})`, () => {
+			writer.line("self.payload = payload");
+		});
+		writer.blank();
+		if (body.kind === "json-flat") emitNamedFactory(writer, "body", body.flattened.map((field) => ({
+			...field,
+			type: resolveType(field.type, operationName, context, "operation-enum")
+		})), (args) => `.init(payload: ${payloadType}(${args}))`);
+		else writer.block(`public static func body(_ value: ${payloadType}) -> Self`, () => {
+			writer.line(".init(payload: value)");
+		});
+	});
+};
+const emitRequestGroupStructs = (writer, method, context) => {
+	if (method.pathParams.length > 0) emitGroupStruct(writer, "Params", "params", pathParamFields(method), method, context);
+	if (method.query.length > 0) emitGroupStruct(writer, "Query", "query", method.query, method, context);
+	if (method.headers.length > 0) emitGroupStruct(writer, "Headers", "headers", method.headers, method, context);
+	emitBodyType(writer, method, context);
+};
+const emitFailureEnum = (writer, method, context) => {
+	writer.blank();
+	const hasDecodedResponse = method.successReturnType !== "Void" || method.errorCases.some((c) => c.type !== "Void");
+	const failureProtocol = hasDecodedResponse ? "KizunaDecodableFailure" : "KizunaFailure";
+	writer.block(`public enum Failure: Swift.Error, Sendable, ${failureProtocol}`, () => {
+		writer.line("case requestFailed(Swift.Error)");
+		writer.line("case invalidRequest");
+		writer.line("case cancelled");
+		writer.line("case invalidResponse");
+		if (hasDecodedResponse) writer.line("case decoding(Swift.Error, statusCode: Int, data: Foundation.Data)");
+		writer.line("case unexpectedStatus(Int, Foundation.Data)");
+		for (const errorCase of method.errorCases) if (errorCase.type === "Void") writer.line(`case ${escapeKeyword(errorCase.caseName)}`);
+		else {
+			const resolved = resolveType(errorCase.type, method.operationName, context, "operation-enum");
+			writer.line(`case ${escapeKeyword(errorCase.caseName)}(${resolved})`);
+		}
+		writer.blank();
+		writer.block("public var isCancelled: Bool", () => {
+			writer.line("if case .cancelled = self { return true }");
+			writer.line("return false");
+		});
+	});
+};
+const emitSuccessSumEnum = (writer, method, context) => {
+	if (!method.successSumEnumName) return;
+	writer.blank();
+	writer.block("public enum Success: Sendable, Equatable", () => {
+		for (const successResponse of method.successResponses) {
+			const resolved = resolveType(successResponse.type, method.operationName, context, "operation-enum");
+			if (resolved === "Void") writer.line(`case status${successResponse.status}`);
+			else writer.line(`case status${successResponse.status}(${resolved})`);
+		}
+	});
+};
+const emitKizunaFailureProtocols = (writer) => {
+	writer.blank();
+	writer.block("public protocol KizunaFailure: Swift.Error", () => {
+		writer.line("static func requestFailed(_ error: Swift.Error) -> Self");
+		writer.line("static var invalidRequest: Self { get }");
+		writer.line("static var cancelled: Self { get }");
+		writer.line("static var invalidResponse: Self { get }");
+		writer.line("static func unexpectedStatus(_ status: Int, _ data: Foundation.Data) -> Self");
+		writer.line("var isCancelled: Bool { get }");
+	});
+	writer.blank();
+	writer.block("public protocol KizunaDecodableFailure: KizunaFailure", () => {
+		writer.line("static func decoding(_ error: Swift.Error, statusCode: Int, data: Foundation.Data) -> Self");
+	});
+};
+const closure = (writer, opener, body) => {
+	writer.line(opener);
+	writer.indent(body);
+	writer.line("}");
+};
+const emitKizunaStreaming = (writer) => {
+	writer.blank();
+	writer.block("struct ServerSentEvent: Sendable", () => {
+		writer.line("let event: String?");
+		writer.line("let data: String");
+		writer.line("let id: String?");
+		writer.line("let retry: Int?");
+	});
+	writer.blank();
+	writer.block("static func open<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, failure: Failure.Type) async throws(Failure) -> (URLSession.AsyncBytes, Int, HTTPURLResponse)", () => {
+		writer.line("if let requestMiddleware {");
+		writer.line("    do { try await requestMiddleware(&request) }");
+		writer.line("    catch is CancellationError { throw Failure.cancelled }");
+		writer.line("    catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+		writer.line("    catch { throw Failure.requestFailed(error) }");
+		writer.line("}");
+		writer.line("let bytes: URLSession.AsyncBytes");
+		writer.line("let response: URLResponse");
+		writer.line("do { (bytes, response) = try await session.bytes(for: request) }");
+		writer.line("catch is CancellationError { throw Failure.cancelled }");
+		writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+		writer.line("catch { throw Failure.requestFailed(error) }");
+		writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
+		writer.line("return (bytes, httpResponse.statusCode, httpResponse)");
+	});
+	writer.blank();
+	writer.block("static func collect<Failure: KizunaFailure>(_ bytes: URLSession.AsyncBytes, failure: Failure.Type) async throws(Failure) -> Foundation.Data", () => {
+		writer.line("var data = Foundation.Data()");
+		writer.line("do { for try await byte in bytes { data.append(byte) } }");
+		writer.line("catch is CancellationError { throw Failure.cancelled }");
+		writer.line("catch { throw Failure.requestFailed(error) }");
+		writer.line("return data");
+	});
+	writer.blank();
+	writer.block("static func lines(_ bytes: URLSession.AsyncBytes) -> AsyncThrowingStream<String, Swift.Error>", () => {
+		closure(writer, "AsyncThrowingStream { continuation in", () => {
+			writer.block("let task = Task", () => {
+				writer.line("var buffer: [UInt8] = []");
+				writer.line("var pendingCarriageReturn = false");
+				writer.block("do", () => {
+					writer.block("for try await byte in bytes", () => {
+						writer.line("if pendingCarriageReturn {");
+						writer.line("    pendingCarriageReturn = false");
+						writer.line("    if byte == 0x0A { continue }");
+						writer.line("}");
+						writer.line("if byte == 0x0A || byte == 0x0D {");
+						writer.line("    pendingCarriageReturn = byte == 0x0D");
+						writer.line("    continuation.yield(String(decoding: buffer, as: UTF8.self))");
+						writer.line("    buffer.removeAll(keepingCapacity: true)");
+						writer.line("    continue");
+						writer.line("}");
+						writer.line("buffer.append(byte)");
+					});
+					writer.line("if !buffer.isEmpty { continuation.yield(String(decoding: buffer, as: UTF8.self)) }");
+					writer.line("continuation.finish()");
+				});
+				writer.line("catch { continuation.finish(throwing: error) }");
+			});
+			writer.line("continuation.onTermination = { _ in task.cancel() }");
+		});
+	});
+	writer.blank();
+	writer.block("static func chunks(_ bytes: URLSession.AsyncBytes) -> AsyncThrowingStream<Foundation.Data, Swift.Error>", () => {
+		closure(writer, "AsyncThrowingStream { continuation in", () => {
+			writer.block("let task = Task", () => {
+				writer.line("var buffer = Foundation.Data()");
+				writer.block("do", () => {
+					writer.block("for try await byte in bytes", () => {
+						writer.line("buffer.append(byte)");
+						writer.line("if buffer.count >= 16_384 {");
+						writer.line("    continuation.yield(buffer)");
+						writer.line("    buffer = Foundation.Data()");
+						writer.line("}");
+					});
+					writer.line("if !buffer.isEmpty { continuation.yield(buffer) }");
+					writer.line("continuation.finish()");
+				});
+				writer.line("catch { continuation.finish(throwing: error) }");
+			});
+			writer.line("continuation.onTermination = { _ in task.cancel() }");
+		});
+	});
+	writer.blank();
+	writer.block("static func serverSentEvents(_ bytes: URLSession.AsyncBytes) -> AsyncThrowingStream<ServerSentEvent, Swift.Error>", () => {
+		closure(writer, "AsyncThrowingStream { continuation in", () => {
+			writer.block("let task = Task", () => {
+				writer.line("var eventType = \"\"");
+				writer.line("var dataLines: [String] = []");
+				writer.line("var lastEventId = \"\"");
+				writer.line("var retry: Int? = nil");
+				writer.block("do", () => {
+					writer.block("for try await line in lines(bytes)", () => {
+						writer.line("if line.isEmpty {");
+						writer.line("    if !dataLines.isEmpty {");
+						writer.line("        continuation.yield(ServerSentEvent(event: eventType.isEmpty ? nil : eventType, data: dataLines.joined(separator: \"\\n\"), id: lastEventId.isEmpty ? nil : lastEventId, retry: retry))");
+						writer.line("        dataLines = []");
+						writer.line("        retry = nil");
+						writer.line("    }");
+						writer.line("    eventType = \"\"");
+						writer.line("    continue");
+						writer.line("}");
+						writer.line("if line.hasPrefix(\":\") { continue }");
+						writer.line("let field: Substring");
+						writer.line("var value: Substring");
+						writer.line("if let separator = line.firstIndex(of: \":\") {");
+						writer.line("    field = line[..<separator]");
+						writer.line("    value = line[line.index(after: separator)...]");
+						writer.line("    if value.hasPrefix(\" \") { value = value.dropFirst() }");
+						writer.line("} else {");
+						writer.line("    field = Substring(line)");
+						writer.line("    value = \"\"");
+						writer.line("}");
+						writer.line("switch field {");
+						writer.line("case \"event\": eventType = String(value)");
+						writer.line("case \"data\": dataLines.append(String(value))");
+						writer.line("case \"id\": if !value.contains(\"\\0\") { lastEventId = String(value) }");
+						writer.line("case \"retry\": if !value.isEmpty, value.allSatisfy(\\.isNumber), let milliseconds = Int(value) { retry = milliseconds }");
+						writer.line("default: break");
+						writer.line("}");
+					});
+					writer.line("continuation.finish()");
+				});
+				writer.line("catch { continuation.finish(throwing: error) }");
+			});
+			writer.line("continuation.onTermination = { _ in task.cancel() }");
+		});
+	});
+	writer.blank();
+	writer.block("static func events<Event: Sendable>(_ bytes: URLSession.AsyncBytes, using decoder: JSONDecoder, _ decode: @escaping @Sendable (ServerSentEvent, JSONDecoder) throws -> Event?) -> AsyncThrowingStream<Event, Swift.Error>", () => {
+		closure(writer, "AsyncThrowingStream { continuation in", () => {
+			writer.block("let task = Task", () => {
+				writer.block("do", () => {
+					writer.block("for try await event in serverSentEvents(bytes)", () => {
+						writer.line("if let decoded = try decode(event, decoder) { continuation.yield(decoded) }");
+					});
+					writer.line("continuation.finish()");
+				});
+				writer.line("catch { continuation.finish(throwing: error) }");
+			});
+			writer.line("continuation.onTermination = { _ in task.cancel() }");
+		});
+	});
+};
+const emitKizunaNamespace = (writer, options) => {
+	writer.blank();
+	writer.block("private enum Kizuna", () => {
+		writer.block("@Sendable static func decodeDate(_ decoder: Decoder) throws -> Date", () => {
+			writer.line("let container = try decoder.singleValueContainer()");
+			writer.line("let raw = try container.decode(String.self)");
+			writer.line("if let date = try? Date(raw, strategy: Date.ISO8601FormatStyle(includingFractionalSeconds: true)) { return date }");
+			writer.line("if let date = try? Date(raw, strategy: Date.ISO8601FormatStyle()) { return date }");
+			writer.line("throw DecodingError.dataCorruptedError(in: container, debugDescription: \"Invalid ISO8601 date: \\(raw)\")");
+		});
+		writer.blank();
+		writer.block("static func encodeDate(_ date: Date) -> String", () => {
+			writer.line("date.formatted(Date.ISO8601FormatStyle(includingFractionalSeconds: true))");
+		});
+		writer.blank();
+		writer.block("static func makeJSONEncoder() -> JSONEncoder", () => {
+			writer.line("let encoder = JSONEncoder()");
+			writer.line("encoder.dateEncodingStrategy = .custom { date, encoder in");
+			writer.line("    var container = encoder.singleValueContainer()");
+			writer.line("    try container.encode(encodeDate(date))");
+			writer.line("}");
+			writer.line("return encoder");
+		});
+		writer.blank();
+		writer.block("static func makeJSONDecoder() -> JSONDecoder", () => {
+			writer.line("let decoder = JSONDecoder()");
+			writer.line("decoder.dateDecodingStrategy = .custom(decodeDate)");
+			writer.line("return decoder");
+		});
+		writer.blank();
+		writer.line("private static let pathSegmentAllowed: CharacterSet = {");
+		writer.line("    var allowed = CharacterSet.urlPathAllowed");
+		writer.line("    allowed.remove(charactersIn: \"/\")");
+		writer.line("    return allowed");
+		writer.line("}()");
+		writer.blank();
+		writer.block("static func encodePathSegment<Value>(_ value: Value) -> String", () => {
+			writer.line("let text = stringifyQueryValue(value).first ?? \"\"");
+			writer.line("return text.addingPercentEncoding(withAllowedCharacters: pathSegmentAllowed) ?? text");
+		});
+		writer.blank();
+		writer.block("static func appendPath(_ base: URL, _ path: String) -> URL", () => {
+			writer.line("base.appending(path: path, directoryHint: .notDirectory)");
+		});
+		writer.blank();
+		writer.block("static func stringifyQueryValue(_ value: Any) -> [String]", () => {
+			writer.line("switch value {");
+			writer.line("case let date as Date:");
+			writer.line("    return [encodeDate(date)]");
+			writer.line("case let array as [Any]:");
+			writer.line("    return array.flatMap { stringifyQueryValue($0) }");
+			writer.line("case let raw as any RawRepresentable where raw.rawValue is CustomStringConvertible:");
+			writer.line("    return [String(describing: raw.rawValue)]");
+			writer.line("case let convertible as CustomStringConvertible:");
+			writer.line("    return [convertible.description]");
+			writer.line("default:");
+			writer.line("    return [String(describing: value)]");
+			writer.line("}");
+		});
+		writer.blank();
+		writer.block("static func queryItems<Value>(name: String, value: Value?) -> [URLQueryItem]", () => {
+			writer.line("guard let value else { return [] }");
+			writer.line("return stringifyQueryValue(value).map { URLQueryItem(name: name, value: $0) }");
+		});
+		writer.blank();
+		writer.block("static func setHeader<Value>(_ request: inout URLRequest, name: String, value: Value?)", () => {
+			writer.line("guard let value else { return }");
+			writer.line("request.setValue(stringifyQueryValue(value).joined(separator: \", \"), forHTTPHeaderField: name)");
+		});
+		writer.blank();
+		writer.block("static func makeURL<Failure: KizunaFailure>(baseURL: URL, path: String, queryItems: [URLQueryItem], failure: Failure.Type) throws(Failure) -> URL", () => {
+			writer.line("guard var components = URLComponents(url: appendPath(baseURL, path), resolvingAgainstBaseURL: false) else {");
+			writer.line("    throw Failure.invalidRequest");
+			writer.line("}");
+			writer.line("if !queryItems.isEmpty { components.queryItems = queryItems }");
+			writer.line("guard let url = components.url else { throw Failure.invalidRequest }");
+			writer.line("return url");
+		});
+		writer.blank();
+		writer.block("static func encodeBody<Value: Encodable, Failure: KizunaFailure>(_ request: inout URLRequest, value: Value, using encoder: JSONEncoder, failure: Failure.Type) throws(Failure)", () => {
+			writer.line("do { request.httpBody = try encoder.encode(value) }");
+			writer.line("catch { throw Failure.requestFailed(error) }");
+		});
+		writer.blank();
+		writer.block("static func send<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?, failure: Failure.Type) async throws(Failure) -> (Foundation.Data, Int, HTTPURLResponse)", () => {
+			writer.line("if let requestMiddleware {");
+			writer.line("    do { try await requestMiddleware(&request) }");
+			writer.line("    catch is CancellationError { throw Failure.cancelled }");
+			writer.line("    catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+			writer.line("    catch { throw Failure.requestFailed(error) }");
+			writer.line("}");
+			writer.line("let data: Foundation.Data");
+			writer.line("let response: URLResponse");
+			writer.line("do { (data, response) = try await session.data(for: request) }");
+			writer.line("catch is CancellationError { throw Failure.cancelled }");
+			writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+			writer.line("catch { throw Failure.requestFailed(error) }");
+			writer.line("if let responseMiddleware { await responseMiddleware(request, data, response) }");
+			writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
+			writer.line("return (data, httpResponse.statusCode, httpResponse)");
+		});
+		writer.blank();
+		writer.block("static func decode<Value: Decodable, Failure: KizunaDecodableFailure>(_ type: Value.Type, from data: Foundation.Data, using decoder: JSONDecoder, statusCode: Int, failure: Failure.Type) throws(Failure) -> Value", () => {
+			writer.line("do { return try decoder.decode(Value.self, from: data) }");
+			writer.line("catch { throw Failure.decoding(error, statusCode: statusCode, data: data) }");
+		});
+		if (options.multiError) {
+			writer.blank();
+			writer.block("static func firstError<Failure: KizunaDecodableFailure>(statusCode: Int, data: Foundation.Data, _ attempts: [() -> Failure?]) -> Failure", () => {
+				writer.line("for attempt in attempts {");
+				writer.line("    if let failure = attempt() { return failure }");
+				writer.line("}");
+				writer.line("return Failure.decoding(DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: \"No matching type for status \\(statusCode)\")), statusCode: statusCode, data: data)");
+			});
+		}
+		if (options.streaming) emitKizunaStreaming(writer);
+		if (options.multipart) {
+			writer.blank();
+			writer.block("struct MultipartBuilder", () => {
+				writer.line("let boundary: String");
+				writer.line("private var data = Foundation.Data()");
+				writer.blank();
+				writer.block("init(boundary: String = \"kizuna-\\(UUID().uuidString)\")", () => {
+					writer.line("self.boundary = boundary");
+				});
+				writer.blank();
+				writer.block("mutating func appendField(name: String, value: String)", () => {
+					writer.line("data.append(\"--\\(boundary)\\r\\n\".data(using: .utf8)!)");
+					writer.line("data.append(\"Content-Disposition: form-data; name=\\\"\\(name)\\\"\\r\\n\\r\\n\".data(using: .utf8)!)");
+					writer.line("data.append(value.data(using: .utf8)!)");
+					writer.line("data.append(\"\\r\\n\".data(using: .utf8)!)");
+				});
+				writer.blank();
+				writer.block(`mutating func appendFile(name: String, file: ${options.clientName}.MultipartFile)`, () => {
+					writer.line("data.append(\"--\\(boundary)\\r\\n\".data(using: .utf8)!)");
+					writer.line("data.append(\"Content-Disposition: form-data; name=\\\"\\(name)\\\"; filename=\\\"\\(file.filename)\\\"\\r\\n\".data(using: .utf8)!)");
+					writer.line("data.append(\"Content-Type: \\(file.mimeType)\\r\\n\\r\\n\".data(using: .utf8)!)");
+					writer.line("data.append(file.data)");
+					writer.line("data.append(\"\\r\\n\".data(using: .utf8)!)");
+				});
+				writer.blank();
+				writer.block("func finalize() -> Foundation.Data", () => {
+					writer.line("var result = data");
+					writer.line("result.append(\"--\\(boundary)--\\r\\n\".data(using: .utf8)!)");
+					writer.line("return result");
+				});
+				writer.blank();
+				writer.block("var contentType: String", () => {
+					writer.line("\"multipart/form-data; boundary=\\(boundary)\"");
+				});
+			});
+		}
+	});
+};
+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 registryStruct = (typeName, context) => {
+	const found = context.registry.get(typeName);
+	return found && found.kind === "struct" && found.fields.length > 0 ? found : void 0;
+};
+const groupMemberAccessor = (groupLabel, field) => `${groupLabel}.${escapeKeyword(field.name)}`;
+const groupTypeRef = (operationName, structName, context) => `${context.clientName}.${operationName}.${structName}`;
+const bodyParamType = (method, context) => {
+	if (!method.body || method.body.kind === "json-empty") return void 0;
+	return groupTypeRef(method.operationName, "Body", context);
+};
+const methodGroups = (method, context) => {
+	const operationName = method.operationName;
+	const groups = [];
+	if (method.pathParams.length > 0) groups.push({
+		varName: "params",
+		type: groupTypeRef(operationName, "Params", context),
+		factory: "params",
+		required: true
+	});
+	const bodyType = bodyParamType(method, context);
+	if (bodyType) groups.push({
+		varName: "body",
+		type: bodyType,
+		factory: "body",
+		required: true
+	});
+	if (method.query.length > 0) groups.push({
+		varName: "query",
+		type: groupTypeRef(operationName, "Query", context),
+		factory: "query",
+		required: method.query.some((field) => !field.optional)
+	});
+	if (method.headers.length > 0) groups.push({
+		varName: "headers",
+		type: groupTypeRef(operationName, "Headers", context),
+		factory: "headers",
+		required: method.headers.some((field) => !field.optional)
+	});
+	return [...groups.filter((group) => group.required), ...groups.filter((group) => !group.required)];
+};
+const buildMethodParameters = (method, context) => methodGroups(method, context).map((group) => `_ ${group.varName}: ${group.type}${group.required ? "" : ` = .${group.factory}()`}`);
+const deprecatedAttribute = (message) => {
+	if (message === void 0 || message === "") return "@available(*, deprecated)";
+	return `@available(*, deprecated, message: ${stringLiteral(message)})`;
+};
+const failureRef = (method, context) => `${context.clientName}.${method.operationName}.${method.failureEnumName}`;
+/**
+* Statement that binds `name` to the decoded response body. JSON responses go
+* through `Kizuna.decode`; binary responses are the raw `Data`; other raw
+* (non-JSON) responses are read as a UTF-8 string.
+*/
+const decodeBodyStatement = (name, resolvedType, response, failure, receiver = "") => {
+	if (response.isBinary) return `    let ${name} = data`;
+	if (response.isRaw) return `    let ${name} = String(decoding: data, as: UTF8.self)`;
+	return `    let ${name} = try Kizuna.decode(${resolvedType}.self, from: data, using: ${receiver}decoder, statusCode: statusCode, failure: ${failure}.self)`;
+};
+const hasMultiErrorGroup = (method) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const errorCase of method.errorCases) counts.set(errorCase.status, (counts.get(errorCase.status) ?? 0) + 1);
+	return [...counts.values()].some((count) => count > 1);
+};
+const emitMethodBody = (writer, method, context, receiver = "") => {
+	const failure = failureRef(method, context);
+	const pathDecl = method.pathParams.length > 0 ? "var" : "let";
+	writer.line(`${pathDecl} path = ${stringLiteral(method.pathTemplate)}`);
+	for (const field of pathParamFields(method)) {
+		const accessor = groupMemberAccessor("params", field);
+		writer.line(`path = path.replacingOccurrences(of: ${stringLiteral(`:${field.name}`)}, with: Kizuna.encodePathSegment(${accessor}))`);
+	}
+	let queryItemsExpression = "[]";
+	if (method.query.length > 0) {
+		writer.line("var queryItems: [URLQueryItem] = []");
+		for (const field of method.query) {
+			const accessor = groupMemberAccessor("query", field);
+			writer.line(`queryItems += Kizuna.queryItems(name: ${stringLiteral(field.wireName)}, value: ${accessor})`);
+		}
+		queryItemsExpression = "queryItems";
+	}
+	writer.line(`let url = try Kizuna.makeURL(baseURL: ${receiver}baseURL, path: path, queryItems: ${queryItemsExpression}, failure: ${failure}.self)`);
+	writer.line(`var request = URLRequest(url: url, cachePolicy: .useProtocolCachePolicy, timeoutInterval: ${receiver}timeout)`);
+	writer.line(`request.httpMethod = ${stringLiteral(method.method)}`);
+	if (context.requestContextFields.length > 0) writer.line(`for (name, value) in ${receiver}requestContextHeaders { request.setValue(value, forHTTPHeaderField: name) }`);
+	if (method.body) emitBodyEncoding(writer, method, context, receiver);
+	for (const field of method.headers) {
+		const accessor = groupMemberAccessor("headers", field);
+		writer.line(`Kizuna.setHeader(&request, name: ${stringLiteral(field.wireName)}, value: ${accessor})`);
+	}
+	const responseBinding = method.resultHeaderFields.length > 0 ? "httpResponse" : "_";
+	if (method.stream) {
+		emitStreamMethodTail(writer, method, context, receiver, responseBinding);
+		return;
+	}
+	writer.line(`let (data, statusCode, ${responseBinding}) = try await Kizuna.send(&request, session: ${receiver}session, requestMiddleware: ${receiver}requestMiddleware, responseMiddleware: ${receiver}responseMiddleware, failure: ${failure}.self)`);
+	writer.line("switch statusCode {");
+	for (const successResponse of method.successResponses) {
+		writer.line(`case ${successResponse.status}:`);
+		if (method.resultWrapperName) {
+			const qualifiedResult = `${context.clientName}.${method.operationName}.${method.resultWrapperName}`;
+			const hasHeaders = method.resultHeaderFields.length > 0;
+			const headersInitArgs = method.resultHeaderFields.map((field) => `${escapeKeyword(field.name)}: ${escapeKeyword(field.name)}`).join(", ");
+			if (method.successSumEnumName) {
+				const resolved = resolveType(successResponse.type, method.operationName, context);
+				if (resolved === "Void") {
+					for (const field of successResponse.responseHeaders) writer.line(`    let ${escapeKeyword(field.name)} = httpResponse.value(forHTTPHeaderField: ${stringLiteral(field.wireName)})`);
+					if (hasHeaders) writer.line(`    return ${qualifiedResult}(body: .status${successResponse.status}, headers: .init(${headersInitArgs}))`);
+					else writer.line(`    return ${qualifiedResult}(body: .status${successResponse.status})`);
+				} else {
+					writer.line(decodeBodyStatement("payload", resolved, successResponse, failure, receiver));
+					for (const field of successResponse.responseHeaders) writer.line(`    let ${escapeKeyword(field.name)} = httpResponse.value(forHTTPHeaderField: ${stringLiteral(field.wireName)})`);
+					if (hasHeaders) writer.line(`    return ${qualifiedResult}(body: .status${successResponse.status}(payload), headers: .init(${headersInitArgs}))`);
+					else writer.line(`    return ${qualifiedResult}(body: .status${successResponse.status}(payload))`);
+				}
+			} else {
+				const resolved = resolveType(successResponse.type, method.operationName, context);
+				writer.line(decodeBodyStatement("body", resolved, successResponse, failure, receiver));
+				for (const field of successResponse.responseHeaders) writer.line(`    let ${escapeKeyword(field.name)} = httpResponse.value(forHTTPHeaderField: ${stringLiteral(field.wireName)})`);
+				if (hasHeaders) writer.line(`    return ${qualifiedResult}(body: body, headers: .init(${headersInitArgs}))`);
+				else writer.line(`    return ${qualifiedResult}(body: body)`);
+			}
+		} else writer.line("    return");
+	}
+	emitErrorCases(writer, method, context, receiver);
+	writer.line("default:");
+	writer.line(`    throw ${failure}.unexpectedStatus(statusCode, data)`);
+	writer.line("}");
+};
+const emitErrorCases = (writer, method, context, receiver, prelude) => {
+	const failure = failureRef(method, context);
+	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(`case ${status}:`);
+		if (prelude) writer.line(`    ${prelude}`);
+		const firstCase = cases[0];
+		if (cases.length === 1 && firstCase) if (firstCase.type === "Void") writer.line(`    throw ${failure}.${escapeKeyword(firstCase.caseName)}`);
+		else {
+			const resolved = resolveType(firstCase.type, method.operationName, context);
+			writer.line(decodeBodyStatement("payload", resolved, firstCase, failure, receiver));
+			writer.line(`    throw ${failure}.${escapeKeyword(firstCase.caseName)}(payload)`);
+		}
+		else {
+			writer.line(`    throw Kizuna.firstError(statusCode: statusCode, data: data, [`);
+			for (const errorCase of cases) {
+				const caseRef = `${failure}.${escapeKeyword(errorCase.caseName)}`;
+				if (errorCase.type === "Void") writer.line(`        { ${caseRef} },`);
+				else if (errorCase.isBinary) writer.line(`        { ${caseRef}(data) },`);
+				else if (errorCase.isRaw) writer.line(`        { ${caseRef}(String(decoding: data, as: UTF8.self)) },`);
+				else {
+					const resolved = resolveType(errorCase.type, method.operationName, context);
+					writer.line(`        { (try? ${receiver}decoder.decode(${resolved}.self, from: data)).map(${caseRef}) },`);
+				}
+			}
+			writer.line("    ])");
+		}
+	}
+};
+const emitStreamMethodTail = (writer, method, context, receiver, responseBinding) => {
+	const failure = failureRef(method, context);
+	const stream = method.stream;
+	const successResponse = method.successResponses.find((candidate) => candidate.status === stream.status);
+	const qualifiedResult = `${context.clientName}.${method.operationName}.${method.resultWrapperName}`;
+	const hasHeaders = method.resultHeaderFields.length > 0;
+	const collect = `let data = try await Kizuna.collect(bytes, failure: ${failure}.self)`;
+	writer.line(`let (bytes, statusCode, ${responseBinding}) = try await Kizuna.open(&request, session: ${receiver}session, requestMiddleware: ${receiver}requestMiddleware, failure: ${failure}.self)`);
+	writer.line("switch statusCode {");
+	writer.line(`case ${stream.status}:`);
+	writer.indent(() => {
+		if (stream.mode === "text") writer.line("let body = Kizuna.lines(bytes)");
+		else if (stream.mode === "binary") writer.line("let body = Kizuna.chunks(bytes)");
+		else if (stream.events) {
+			const events = stream.events;
+			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder) { event, decoder -> ${streamElementType(method, context, "actor")}? in`, () => {
+				writer.line("switch event.event {");
+				for (const event of events) {
+					const payloadType = resolveType(event.type, method.operationName, context);
+					writer.line(`case ${stringLiteral(event.name)}: return .${escapeKeyword(event.caseName)}(try decoder.decode(${payloadType}.self, from: Foundation.Data(event.data.utf8)))`);
+				}
+				writer.line("default: return nil");
+				writer.line("}");
+			});
+		} else {
+			const elementType = streamElementType(method, context, "actor");
+			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder) { event, decoder -> ${elementType}? in`, () => {
+				writer.line(`try decoder.decode(${elementType}.self, from: Foundation.Data(event.data.utf8))`);
+			});
+		}
+		for (const field of successResponse.responseHeaders) writer.line(`let ${escapeKeyword(field.name)} = httpResponse.value(forHTTPHeaderField: ${stringLiteral(field.wireName)})`);
+		if (hasHeaders) {
+			const headersInitArgs = method.resultHeaderFields.map((field) => `${escapeKeyword(field.name)}: ${escapeKeyword(field.name)}`).join(", ");
+			writer.line(`return ${qualifiedResult}(body: body, headers: .init(${headersInitArgs}))`);
+		} else writer.line(`return ${qualifiedResult}(body: body)`);
+	});
+	emitErrorCases(writer, method, context, receiver, collect);
+	writer.line("default:");
+	writer.line(`    ${collect}`);
+	writer.line(`    throw ${failure}.unexpectedStatus(statusCode, data)`);
+	writer.line("}");
+};
+const methodSuccessType = (method, context) => {
+	const { clientName } = context;
+	if (method.resultWrapperName) return `${clientName}.${method.operationName}.${method.resultWrapperName}`;
+	if (method.successReturnType === "Void") return "Void";
+	if (method.successSumEnumName) return `${clientName}.${method.operationName}.Success`;
+	return resolveType(method.successReturnType, method.operationName, context);
+};
+const buildMethodSignature = (method, context) => {
+	const failure = failureRef(method, context);
+	const params = buildMethodParameters(method, context);
+	const successType = methodSuccessType(method, context);
+	const returnType = successType === "Void" ? "" : ` -> ${successType}`;
+	return `public func ${escapeKeyword(method.name)}(${params.join(", ")}) async throws(${failure})${returnType}`;
+};
+const emitMethod = (writer, method, context) => {
+	writer.docComment(method.summary ?? method.description);
+	if (method.deprecated) writer.line(deprecatedAttribute(method.deprecationMessage));
+	writer.block(buildMethodSignature(method, context), () => {
+		emitMethodBody(writer, method, context);
+	});
+};
+const emitSubClientMethod = (writer, method, context) => {
+	writer.docComment(method.summary ?? method.description);
+	if (method.deprecated) writer.line(deprecatedAttribute(method.deprecationMessage));
+	writer.block(buildMethodSignature(method, context), () => {
+		emitMethodBody(writer, method, context, "client.");
+	});
+};
+const emitSubClientStruct = (writer, group, clientName, context) => {
+	writer.blank();
+	writer.block(`public struct ${group.structName}: Sendable`, () => {
+		writer.line(`private let client: ${clientName}`);
+		writer.blank();
+		writer.block(`init(client: ${clientName})`, () => {
+			writer.line("self.client = client");
+		});
+		for (const method of group.methods) {
+			writer.blank();
+			emitSubClientMethod(writer, method, context);
+		}
+	});
+};
+const emitBodyEncoding = (writer, method, context, receiver = "") => {
+	if (!method.body) return;
+	const body = method.body;
+	const failure = failureRef(method, context);
+	if (body.kind === "multipart") {
+		writer.line("var multipart = Kizuna.MultipartBuilder()");
+		for (const field of body.multipartFields) {
+			const flattenedField = body.flattened.find((candidate) => candidate.name === field.name);
+			const accessor = `body.${escapeKeyword(field.name)}`;
+			if (field.isFile || flattenedField?.isFile === true) writer.line(`multipart.appendFile(name: ${stringLiteral(field.wireName)}, file: ${accessor})`);
+			else writer.line(`multipart.appendField(name: ${stringLiteral(field.wireName)}, value: String(describing: ${accessor}))`);
+		}
+		writer.line("request.httpBody = multipart.finalize()");
+		writer.line("request.setValue(multipart.contentType, forHTTPHeaderField: \"Content-Type\")");
+		return;
+	}
+	writer.line("request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")");
+	if (body.kind === "json-empty") {
+		writer.line("request.httpBody = Data(\"{}\".utf8)");
+		return;
+	}
+	writer.line(`try Kizuna.encodeBody(&request, value: body.payload, using: ${receiver}encoder, failure: ${failure}.self)`);
+};
+const emitClient = (writer, config, partition, context, typesByOperation) => {
+	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);
+	writer.blank();
+	writer.block(`public final class ${clientName}: Sendable`, () => {
+		if (contextFields.length > 0) {
+			writer.blank();
+			writer.docComment("Values sent as headers on every request, from the api's request context.");
+			writer.block("public struct RequestContext: Sendable, Equatable", () => {
+				for (const field of contextFields) writer.line(`public var ${escapeKeyword(field.name)}: ${field.type}`);
+				writer.blank();
+				const initParams = contextFields.map((field) => `${escapeKeyword(field.name)}: ${field.type}${field.optional ? " = nil" : ""}`).join(", ");
+				writer.block(`public init(${initParams})`, () => {
+					for (const field of contextFields) writer.line(`self.${escapeKeyword(field.name)} = ${escapeKeyword(field.name)}`);
+				});
+				writer.blank();
+				writer.block("var headerFields: [String: String]", () => {
+					writer.line("var fields: [String: String] = [:]");
+					for (const field of contextFields) if (field.optional) writer.line(`if let ${escapeKeyword(field.name)} { fields[${stringLiteral(field.wireName)}] = ${escapeKeyword(field.name)} }`);
+					else writer.line(`fields[${stringLiteral(field.wireName)}] = ${escapeKeyword(field.name)}`);
+					writer.line("return fields");
+				});
+			});
+		}
+		if (usesMultipart) {
+			writer.blank();
+			writer.block("public struct MultipartFile: Sendable, Equatable", () => {
+				writer.line("public let data: Foundation.Data");
+				writer.line("public let filename: String");
+				writer.line("public let mimeType: String");
+				writer.blank();
+				writer.block("public init(data: Data, filename: String, mimeType: String = \"application/octet-stream\")", () => {
+					writer.line("self.data = data");
+					writer.line("self.filename = filename");
+					writer.line("self.mimeType = mimeType");
+				});
+			});
+		}
+		if (allMethods.some((method) => method.errorCases.some((c) => c.type === "ValidationError"))) {
+			writer.blank();
+			writer.block("public struct ValidationError: Codable, Sendable, Equatable", () => {
+				writer.line("public let type: String");
+				writer.line("public let title: String");
+				writer.line("public let status: Int");
+				writer.line("public let detail: String");
+				writer.line("public let errors: [ValidationIssue]");
+				writer.blank();
+				writer.block("public init(type: String, title: String, status: Int, detail: String, errors: [ValidationIssue])", () => {
+					writer.line("self.type = type");
+					writer.line("self.title = title");
+					writer.line("self.status = status");
+					writer.line("self.detail = detail");
+					writer.line("self.errors = errors");
+				});
+			});
+			writer.blank();
+			writer.block("public struct ValidationIssue: Codable, Sendable, Equatable", () => {
+				writer.line("public let code: String");
+				writer.line("public let path: [String]");
+				writer.line("public let message: String");
+				writer.blank();
+				writer.block("public init(code: String, path: [String], message: String)", () => {
+					writer.line("self.code = code");
+					writer.line("self.path = path");
+					writer.line("self.message = message");
+				});
+			});
+		}
+		if (config.anyCodable) {
+			writer.blank();
+			writer.docComment("A decoded JSON value of unknown shape. Codable and correctly Equatable by structure.");
+			writer.block("public enum JSONValue: Codable, Sendable, Equatable", () => {
+				writer.line("case null");
+				writer.line("case bool(Bool)");
+				writer.line("case int(Int)");
+				writer.line("case double(Double)");
+				writer.line("case string(String)");
+				writer.line("case array([JSONValue])");
+				writer.line("case object([String: JSONValue])");
+				writer.blank();
+				writer.block("public init(from decoder: Decoder) throws", () => {
+					writer.line("let container = try decoder.singleValueContainer()");
+					writer.line("if container.decodeNil() {");
+					writer.line("    self = .null");
+					writer.line("} else if let value = try? container.decode(Bool.self) {");
+					writer.line("    self = .bool(value)");
+					writer.line("} else if let value = try? container.decode(Int.self) {");
+					writer.line("    self = .int(value)");
+					writer.line("} else if let value = try? container.decode(Double.self) {");
+					writer.line("    self = .double(value)");
+					writer.line("} else if let value = try? container.decode(String.self) {");
+					writer.line("    self = .string(value)");
+					writer.line("} else if let value = try? container.decode([JSONValue].self) {");
+					writer.line("    self = .array(value)");
+					writer.line("} else if let value = try? container.decode([String: JSONValue].self) {");
+					writer.line("    self = .object(value)");
+					writer.line("} else {");
+					writer.line("    throw DecodingError.dataCorruptedError(in: container, debugDescription: \"Unsupported JSON value\")");
+					writer.line("}");
+				});
+				writer.blank();
+				writer.block("public func encode(to encoder: Encoder) throws", () => {
+					writer.line("var container = encoder.singleValueContainer()");
+					writer.line("switch self {");
+					writer.line("case .null: try container.encodeNil()");
+					writer.line("case .bool(let value): try container.encode(value)");
+					writer.line("case .int(let value): try container.encode(value)");
+					writer.line("case .double(let value): try container.encode(value)");
+					writer.line("case .string(let value): try container.encode(value)");
+					writer.line("case .array(let value): try container.encode(value)");
+					writer.line("case .object(let value): try container.encode(value)");
+					writer.line("}");
+				});
+			});
+		}
+		writer.line("public let baseURL: URL");
+		writer.line("public let session: URLSession");
+		writer.line("public let timeout: TimeInterval");
+		if (contextFields.length > 0) writer.line("let requestContextHeaders: [String: String]");
+		writer.line("public let requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?");
+		writer.line("public let responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?");
+		writer.line("let encoder: JSONEncoder");
+		writer.line("let decoder: JSONDecoder");
+		writer.blank();
+		const contextInitParam = contextFields.length > 0 ? `, requestContext: RequestContext${contextRequired ? "" : " = RequestContext()"}` : "";
+		writer.block(`public init(baseURL: URL, session: URLSession = .shared, timeout: TimeInterval = 30${contextInitParam}, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)? = nil, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)? = nil)`, () => {
+			writer.line("self.baseURL = baseURL");
+			writer.line("self.session = session");
+			writer.line("self.timeout = timeout");
+			if (contextFields.length > 0) writer.line("self.requestContextHeaders = requestContext.headerFields");
+			writer.line("self.requestMiddleware = requestMiddleware");
+			writer.line("self.responseMiddleware = responseMiddleware");
+			writer.line("self.encoder = Kizuna.makeJSONEncoder()");
+			writer.line("self.decoder = Kizuna.makeJSONDecoder()");
+		});
+		if (groups.length > 0) for (const group of groups) {
+			writer.blank();
+			writer.block(`public var ${escapeKeyword(group.propertyName)}: ${group.structName}`, () => {
+				writer.line(`${group.structName}(client: self)`);
+			});
+		}
+		for (const method of allMethods) {
+			const localTypes = (typesByOperation.get(method.operationName) ?? []).map((type) => localizeType(type, method.operationName, context));
+			writer.blank();
+			writer.block(`public enum ${method.operationName}`, () => {
+				emitTypes(writer, localTypes, context);
+				emitRequestGroupStructs(writer, method, context);
+				emitSuccessSumEnum(writer, method, context);
+				emitEventEnum(writer, method, context);
+				emitToolTracking(writer, method);
+				emitResultStruct(writer, method, context);
+				emitFailureEnum(writer, method, context);
+			});
+		}
+		for (const method of flatMethods) {
+			writer.blank();
+			emitMethod(writer, method, context);
+		}
+	});
+};
+/**
+* Generate a Swift API client from a kizuna config.
+*
+*   - `namespaceName`: the actor class. Defaults to `APIClient`.
+*/
+const generateSwiftClient = (api, options) => {
+	const { namespaceName, camelCaseProperties = false, unknownEnumCase = false } = options;
+	const registry = new TypeRegistry(camelCaseProperties, unknownEnumCase);
+	const partition = swiftGenerator(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 SwiftWriter();
+	writer.line("// Generated by @kizunajs/swift. Do not edit by hand.");
+	writer.blank();
+	writer.line("import Foundation");
+	writer.line("#if canImport(FoundationNetworking)");
+	writer.line("import FoundationNetworking");
+	writer.line("#endif");
+	writer.blank();
+	const usesMultipart = allMethods.some((method) => method.body?.kind === "multipart");
+	const usesMultiError = allMethods.some(hasMultiErrorGroup);
+	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 allStructNames = sharedTypes.filter((type) => type.kind === "struct").map((type) => type.name);
+	const ownedTypeMap = /* @__PURE__ */ new Map();
+	const sharedTypeNames = new Set(sharedTypes.map((type) => type.name));
+	for (const type of sharedTypes) {
+		if (registry.isExplicitId(type.name)) continue;
+		const unionOwner = registry.unionVariantOwner(type.name);
+		if (unionOwner !== void 0 && sharedTypeNames.has(unionOwner)) {
+			ownedTypeMap.set(type.name, unionOwner);
+			continue;
+		}
+		let bestMatch;
+		for (const structName of allStructNames) {
+			if (structName === type.name) continue;
+			if ((0, kizunajs_generator.isHintPrefix)(type.name, structName) && (!bestMatch || structName.length > bestMatch.length)) bestMatch = structName;
+		}
+		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));
+	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,
+		registry,
+		requestContextFields
+	};
+	writer.block(`public enum ${namespaceName}`, () => {
+		emitTypes(writer, topLevelSharedTypes, context, ownedTypeMap, ownedTypeLookup);
+	});
+	emitClient(writer, {
+		clientName,
+		anyCodable: registry.usesAnyCodable
+	}, partition, context, typesByOperation);
+	for (const group of partition.groups) emitSubClientStruct(writer, group, clientName, context);
+	emitKizunaFailureProtocols(writer);
+	emitKizunaNamespace(writer, {
+		multipart: usesMultipart,
+		multiError: usesMultiError,
+		streaming: allMethods.some((method) => method.stream !== void 0),
+		clientName
+	});
+	for (const warning of registry.warnings()) process.stderr.write(`[kizuna/swift] AnyCodable fallback at ${warning}\n`);
+	return writer.toString();
+};
+//#endregion
+Object.defineProperty(exports, "generateSwiftClient", {
+	enumerable: true,
+	get: function() {
+		return generateSwiftClient;
+	}
+});