@huanglangjian/specs 0.3.1 → 0.5.0

package/dist/index.mjs

@@ -1,20 +1,11 @@
-import { resolve } from "pathe";
-import { format } from "prettier";
-import PrettierJavaPlugin from "prettier-plugin-java";
-import PrettierRustPlugin from "prettier-plugin-rust";
-//#region src/type-system/basic.ts
+import { camelCase, pascalCase } from "text-case";
+//#region src/types.ts
 function int32(options) {
 	return {
 		kind: "int32",
 		...options
 	};
 }
-function int64(options) {
-	return {
-		kind: "int64",
-		...options
-	};
-}
 function float32(options) {
 	return {
 		kind: "float32",
@@ -39,56 +30,54 @@ function string(options) {
 		...options
 	};
 }
-function literal(options) {
+function array(options) {
 	return {
-		kind: "literal",
+		kind: "array",
 		...options
 	};
 }
-/**
-* 创建一个可选类型模型。
-*
-* @param base 基础模型类型
-* @param options 可选配置选项
-* @returns 可选类型模型
-*/
-function optional(base, options) {
+function set(options) {
 	return {
-		kind: "optional",
-		base,
+		kind: "set",
 		...options
 	};
 }
-function array(base, options) {
+function map(options) {
 	return {
-		kind: "array",
-		base,
+		kind: "map",
 		...options
 	};
 }
-function set(base, options) {
+function record(options) {
 	return {
-		kind: "set",
-		base,
+		kind: "record",
 		...options
 	};
 }
-function map(base, options) {
+function union(options) {
 	return {
-		kind: "map",
-		base,
+		kind: "union",
 		...options
 	};
 }
-function record(options) {
+function taggedUnion(options) {
 	return {
-		kind: "record",
+		kind: "taggedUnion",
 		...options
 	};
 }
-function union(options) {
+function literal(value) {
 	return {
-		kind: "union",
+		kind: "literal",
+		value
+	};
+}
+function nullLike() {
+	return { kind: "null" };
+}
+function enums(options) {
+	return {
+		kind: "enums",
 		...options
 	};
 }
@@ -110,901 +99,1456 @@ function duration(options) {
 		...options
 	};
 }
-function error(options) {
+//#endregion
+//#region src/api.ts
+function route(options) {
 	return {
-		kind: "error",
+		kind: "route",
 		...options
 	};
 }
-function enums(options) {
+function json(options) {
 	return {
-		kind: "enums",
+		kind: "json-response",
 		...options
 	};
 }
-function taggedUnion(options) {
+function jsonStream(options) {
+	return {
+		kind: "stream-response",
+		...options
+	};
+}
+function sseStream(options) {
 	return {
-		kind: "tagged-union",
+		kind: "sse-response",
 		...options
 	};
 }
+function binary(options) {
+	return {
+		kind: "binary",
+		...options
+	};
+}
+//#endregion
+//#region src/security.ts
+function apikey(options) {
+	const component = {
+		kind: "apikey",
+		...options
+	};
+	return {
+		...component,
+		apply: () => ({
+			component,
+			scopes: []
+		})
+	};
+}
+function openIdConnect(options) {
+	const component = {
+		kind: "openIdConnect",
+		...options
+	};
+	return {
+		...component,
+		apply: (...scopes) => ({
+			component,
+			scopes
+		})
+	};
+}
+//#endregion
+//#region src/deployment.ts
+function deployOpenIdConnect(options) {
+	return {
+		kind: "openIdConnectDeployment",
+		component: options.component,
+		issuer: options.issuer
+	};
+}
+//#endregion
+//#region src/generate-jsonschema.ts
 function generateJsonSchema(options) {
-	const { model, target = "draft-2020-12", reference = "json-schema", depth = 0 } = options ?? {};
-	const $schema = getSchemaRef(target);
-	const convert = (partial) => ({
-		$schema: depth === 0 ? $schema : void 0,
-		title: model.title,
-		description: model.description,
-		examples: model.examples,
-		deprecated: model.deprecated,
-		default: model.default,
-		...partial,
-		..."schema" in model ? model.schema : {}
-	});
-	const getReferenceSchema = (schema) => {
-		switch (reference) {
-			case "inline": return generateJsonSchema({
-				model: schema,
-				target,
-				reference,
-				depth: depth + 1
-			});
-			case "json-schema": return schema.id != null ? { $ref: "#/$defs/" + schema.id } : generateJsonSchema({
-				model: schema,
-				target,
-				reference,
-				depth: depth + 1
+	const { model, toJsonSchema = () => ({}) } = options;
+	const registry = options.registry ?? createJsonSchemaRegistry();
+	const schema = toJsonSchema(model.schema);
+	switch (model.kind) {
+		case "int32": return {
+			jsonSchema: {
+				...schema,
+				type: "integer",
+				format: "int32"
+			},
+			registry
+		};
+		case "float32": return {
+			jsonSchema: {
+				...schema,
+				type: "number",
+				format: "float"
+			},
+			registry
+		};
+		case "float64": return {
+			jsonSchema: {
+				...schema,
+				type: "number",
+				format: "float"
+			},
+			registry
+		};
+		case "boolean": return {
+			jsonSchema: {
+				...schema,
+				type: "boolean"
+			},
+			registry
+		};
+		case "null": return {
+			jsonSchema: {
+				...schema,
+				type: "null"
+			},
+			registry
+		};
+		case "enums": return {
+			jsonSchema: {
+				...schema,
+				type: "string",
+				enum: Object.values(model.variants)
+			},
+			registry
+		};
+		case "datetime": return {
+			jsonSchema: {
+				...schema,
+				type: "string",
+				format: "date-time"
+			},
+			registry
+		};
+		case "date": return {
+			jsonSchema: {
+				...schema,
+				type: "string",
+				format: "date"
+			},
+			registry
+		};
+		case "duration": return {
+			jsonSchema: {
+				...schema,
+				type: "string",
+				format: "duration"
+			},
+			registry
+		};
+		case "literal": return {
+			jsonSchema: {
+				...schema,
+				const: model.value
+			},
+			registry
+		};
+		case "string": return {
+			jsonSchema: {
+				...schema,
+				type: "string"
+			},
+			registry
+		};
+		case "array": {
+			const { jsonSchema, registry: newRegistry } = generateJsonSchema({
+				model: model.base,
+				registry,
+				toJsonSchema
 			});
-			case "openapi": return schema.id != null ? { $ref: "#/components/schemas/" + schema.id } : generateJsonSchema({
-				model: schema,
-				target,
-				reference,
-				depth: depth + 1
+			return {
+				jsonSchema: {
+					...schema,
+					type: "array",
+					items: jsonSchema
+				},
+				registry: newRegistry
+			};
+		}
+		case "map": {
+			const { jsonSchema, registry: newRegistry } = generateJsonSchema({
+				model: model.base,
+				registry,
+				toJsonSchema
 			});
+			return {
+				jsonSchema: {
+					...schema,
+					type: "object",
+					additionalProperties: jsonSchema
+				},
+				registry: newRegistry
+			};
 		}
-	};
-	switch (model.kind) {
-		case "int32": return convert({
-			type: "integer",
-			format: "int32"
-		});
-		case "float32": return convert({
-			type: "number",
-			format: "float"
-		});
-		case "float64": return convert({
-			type: "number",
-			format: "float"
-		});
-		case "int64": return convert({
-			type: "string",
-			format: "int64"
-		});
-		case "boolean": return convert({ type: "boolean" });
-		case "string": return convert({ type: "string" });
-		case "literal": return convert({ const: model.value });
-		case "optional": {
-			const baseSchema = getReferenceSchema(model.base);
-			if ("$ref" in baseSchema) return convert({ oneOf: [baseSchema, { type: "null" }] });
-			const { type = [], ...others } = baseSchema;
-			return convert({
-				type: Array.isArray(type) ? [...new Set([...type, "null"])] : [type, "null"],
-				...others
+		case "set": {
+			const { jsonSchema, registry: newRegistry } = generateJsonSchema({
+				model: model.base,
+				registry,
+				toJsonSchema
 			});
+			return {
+				jsonSchema: {
+					...schema,
+					type: "array",
+					items: jsonSchema,
+					uniqueItems: true
+				},
+				registry: newRegistry
+			};
 		}
-		case "array": return convert({
-			type: "array",
-			items: getReferenceSchema(model.base)
-		});
-		case "set": return {
-			$schema,
-			type: "array",
-			items: getReferenceSchema(model.base),
-			uniqueItems: true
-		};
-		case "map": return convert({
-			type: "object",
-			additionalProperties: getReferenceSchema(model.base)
-		});
-		case "record": return convert({
-			type: "object",
-			properties: Object.fromEntries(Object.entries(model.properties).map(([k, v]) => [k, getReferenceSchema(v)])),
-			required: Object.entries(model.properties).filter(([_, v]) => v.kind !== "optional").map(([k]) => k),
-			additionalProperties: false
-		});
-		case "union": return convert({ oneOf: Object.entries(model.variants).map(([k, v]) => ({
-			type: "object",
-			title: v.title ?? k,
-			properties: { [k]: getReferenceSchema(v) },
-			required: [k],
-			additionalProperties: false
-		})) });
-		case "tagged-union": return convert({ oneOf: Object.values(model.variants).map((o) => getReferenceSchema(o)) });
-		case "datetime": return convert({
-			type: "string",
-			format: "date-time"
-		});
-		case "date": return convert({
-			type: "string",
-			format: "date"
-		});
-		case "duration": return convert({
-			type: "string",
-			format: "duration"
-		});
-		case "error": return convert({
-			type: "object",
-			properties: {
-				code: { const: model.code },
-				context: model.context == null ? void 0 : {
+		case "record": {
+			const result = Object.entries(model.properties).reduce((acc, [key, propModel]) => {
+				const ref = acc.registry.getRef(propModel);
+				if (ref) return {
+					registry: acc.registry,
+					properties: {
+						...acc.properties,
+						[key]: { $ref: ref }
+					}
+				};
+				const generated = generateJsonSchema({
+					model: propModel,
+					registry: acc.registry,
+					toJsonSchema
+				});
+				return {
+					registry: generated.registry,
+					properties: {
+						...acc.properties,
+						[key]: generated.jsonSchema
+					}
+				};
+			}, {
+				registry,
+				properties: {}
+			});
+			return {
+				jsonSchema: {
+					...schema,
 					type: "object",
-					properties: Object.fromEntries(Object.entries(model.context).map(([k, v]) => [k, getReferenceSchema(v)])),
-					additionalProperties: false
-				}
-			},
-			additionalProperties: false
-		});
-		case "enums": return convert({
-			type: "string",
-			enum: Object.values(model.variants)
-		});
+					required: model.required,
+					additionalProperties: false,
+					properties: result.properties
+				},
+				registry: result.registry
+			};
+		}
+		case "union": {
+			const result = Object.entries(model.variants).reduce((acc, [key, variantModel]) => {
+				const ref = acc.registry.getRef(variantModel);
+				if (ref) return {
+					registry: acc.registry,
+					oneOf: [...acc.oneOf, {
+						type: "object",
+						required: [key],
+						properties: { [key]: { $ref: ref } }
+					}]
+				};
+				const generated = generateJsonSchema({
+					model: variantModel,
+					registry: acc.registry,
+					toJsonSchema
+				});
+				return {
+					registry: generated.registry,
+					oneOf: [...acc.oneOf, {
+						type: "object",
+						required: [key],
+						properties: { [key]: generated.jsonSchema }
+					}]
+				};
+			}, {
+				registry,
+				oneOf: []
+			});
+			return {
+				jsonSchema: {
+					...schema,
+					oneOf: result.oneOf
+				},
+				registry: result.registry
+			};
+		}
+		case "taggedUnion": {
+			const result = Object.entries(model.variants).reduce((acc, [key, variantModel]) => {
+				const ref = acc.registry.getRef(variantModel);
+				if (ref) return {
+					registry: acc.registry,
+					oneOf: [...acc.oneOf, {
+						type: "object",
+						required: [model.variantKey, model.payloadKey],
+						properties: {
+							[model.variantKey]: { const: key },
+							[model.payloadKey]: { $ref: ref }
+						}
+					}]
+				};
+				const generated = generateJsonSchema({
+					model: variantModel,
+					registry: acc.registry,
+					toJsonSchema
+				});
+				return {
+					registry: generated.registry,
+					oneOf: [...acc.oneOf, {
+						type: "object",
+						required: [model.variantKey, model.payloadKey],
+						properties: {
+							[model.variantKey]: { const: key },
+							[model.payloadKey]: generated.jsonSchema
+						}
+					}]
+				};
+			}, {
+				registry,
+				oneOf: []
+			});
+			return {
+				jsonSchema: {
+					...schema,
+					oneOf: result.oneOf
+				},
+				registry: result.registry
+			};
+		}
 	}
 }
-function getSchemaRef(target) {
-	switch (target) {
-		case "draft-2020-12": return "https://json-schema.org/draft/2020-12/schema";
-	}
+function createJsonSchemaRegistry(models) {
+	const map = new Map(models);
+	const registry = {
+		getRef(model) {
+			const entry = map.get(model);
+			return entry ? "#/$defs/" + entry.id : void 0;
+		},
+		add(id, model) {
+			const { jsonSchema } = generateJsonSchema({
+				model,
+				registry
+			});
+			return createJsonSchemaRegistry(map.set(model, {
+				id,
+				schema: jsonSchema
+			}));
+		}
+	};
+	return registry;
+}
+function createOpenapiSchemaRegistry(models) {
+	const map = new Map(models);
+	const registry = {
+		getRef(model) {
+			const entry = map.get(model);
+			return entry ? "#/components/schemas/" + entry.id : void 0;
+		},
+		add(id, model) {
+			const { jsonSchema } = generateJsonSchema({
+				model,
+				registry
+			});
+			return createOpenapiSchemaRegistry(map.set(model, {
+				id,
+				schema: jsonSchema
+			}));
+		}
+	};
+	return registry;
 }
 //#endregion
-//#region src/type-system/http.ts
+//#region src/generate-openapi.ts
+function joinPath$1(basePath, routePath) {
+	if (!basePath) return routePath;
+	return `${basePath.endsWith("/") ? basePath.slice(0, -1) : basePath}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
+}
 function generateOpenapi(options) {
-	const { info, routes, securitySchemes, tags, servers } = options;
-	const models = collectModelFromRoutes(routes);
-	return {
-		openapi: "3.2.0",
-		info,
-		paths: generatePathsObject(routes),
-		components: {
-			schemas: Object.fromEntries(generateComponentSchemasFromModels(models)),
-			securitySchemes
+	const { info, servers, routers, security } = options;
+	const flatRoutes = routers.flatMap((rm) => Object.entries(rm.routes).map(([_key, route]) => ({
+		route,
+		group: rm.name,
+		fullPath: joinPath$1(rm.basePath ?? "", route.path)
+	})));
+	const namedModels = collectNamedModels$1(flatRoutes.map((fr) => fr.route));
+	const registry = [...namedModels.entries()].reduce((reg, [id, model]) => reg.add(id, model), createOpenapiSchemaRegistry());
+	const schemas = [...namedModels.entries()].reduce((acc, [id, model]) => ({
+		...acc,
+		[id]: generateJsonSchema({
+			model,
+			registry
+		}).jsonSchema
+	}), {});
+	const hasSchemas = Object.keys(schemas).length > 0;
+	const paths = generatePaths(flatRoutes, registry);
+	let components = hasSchemas ? { schemas } : void 0;
+	if (security?.policy) {
+		const schemeResult = buildSecuritySchemes(security.policy, security.deployments);
+		if (schemeResult.schemes && Object.keys(schemeResult.schemes).length > 0) components = {
+			...components,
+			securitySchemes: schemeResult.schemes
+		};
+		const securedPaths = applySecurityToPaths(paths, security.policy);
+		if (securedPaths) return {
+			openapi: {
+				openapi: "3.2.0",
+				info,
+				servers,
+				paths: securedPaths,
+				components
+			},
+			registry
+		};
+	}
+	return {
+		openapi: {
+			openapi: "3.2.0",
+			info,
+			servers,
+			paths,
+			components
 		},
-		tags,
-		servers
+		registry
 	};
 }
-function collectModelFromRoutes(routes) {
-	const models = /* @__PURE__ */ new Map();
-	for (const route of routes) for (const [id, model] of collectModelsFromRoute(route)) models.set(id, model);
-	return models;
-}
-function collectModelDeep(model) {
-	const ret = /* @__PURE__ */ new Map();
-	if (model.id != null) ret.set(model.id, model);
-	switch (model.kind) {
-		case "optional":
-		case "array":
-		case "set":
-		case "map":
-			for (const [id, nestModel] of collectModelDeep(model.base)) ret.set(id, nestModel);
-			return ret;
-		case "record":
-			for (const property of Object.values(model.properties)) for (const [id, nestedModel] of collectModelDeep(property)) ret.set(id, nestedModel);
-			return ret;
-		case "union":
-			for (const variant of Object.values(model.variants)) for (const [id, nestedModel] of collectModelDeep(variant)) ret.set(id, nestedModel);
-			return ret;
-		case "error":
-			if (model.context) for (const detail of Object.values(model.context)) for (const [id, nestedModel] of collectModelDeep(detail)) ret.set(id, nestedModel);
-			return ret;
-		default: return ret;
-	}
+function collectNamedModels$1(routes) {
+	return routes.reduce((models, route) => {
+		return [...collectModelsFromRoute(route).entries()].reduce((acc, [id, model]) => {
+			if (!acc.has(id)) acc.set(id, model);
+			return acc;
+		}, models);
+	}, /* @__PURE__ */ new Map());
 }
 function collectModelsFromRoute(route) {
-	const models = /* @__PURE__ */ new Map();
-	for (const model of [
-		route.variables,
-		route.queries,
-		route.headers,
-		route.cookies
-	].filter((o) => !!o).flatMap(Object.values)) for (const [id, subModel] of collectModelDeep(model)) models.set(id, subModel);
-	if (route.content) for (const [id, subModel] of collectModelsFromContent(route.content)) models.set(id, subModel);
-	if (route.responses) for (const response of Object.values(route.responses)) for (const [id, subModel] of collectModelsFromResponse(response)) models.set(id, subModel);
-	return models;
-}
-function collectModelsFromContent(content) {
-	const models = /* @__PURE__ */ new Map();
-	if (content.kind !== "binary-stream-content") {
-		if (content.model) for (const [id, subModel] of collectModelDeep(content.model)) models.set(id, subModel);
-	}
-	return models;
+	return [route.body, ...Object.values(route.responses).flatMap(collectModelsFromResponse)].filter((m) => m != null).reduce((acc, model) => {
+		return collectModelDeep(model).reduce((inner, [id, m]) => {
+			if (!inner.has(id)) inner.set(id, m);
+			return inner;
+		}, acc);
+	}, /* @__PURE__ */ new Map());
 }
 function collectModelsFromResponse(response) {
-	const models = /* @__PURE__ */ new Map();
-	for (const model of [response.cookies, response.headers].filter((o) => !!o).flatMap(Object.values)) for (const [id, subModel] of collectModelDeep(model)) models.set(id, subModel);
-	if (response.content) for (const [id, subModel] of collectModelsFromContent(response.content)) models.set(id, subModel);
-	return models;
-}
-function generateComponentSchemasFromModels(models) {
-	const ret = /* @__PURE__ */ new Map();
-	for (const [id, model] of models) {
-		const schema = generateJsonSchema({
-			model,
-			reference: "openapi"
-		});
-		ret.set(id, schema);
+	switch (response.kind) {
+		case "json-response":
+		case "stream-response":
+		case "sse-response": return response.body ? [response.body] : [];
+		case "binary": return [];
 	}
-	return ret;
 }
-function generatePathsObject(routes) {
-	const pathItems = /* @__PURE__ */ new Map();
-	for (const route of routes) {
-		const item = pathItems.get(route.path) ?? {};
-		pathItems.set(route.path, {
-			...item,
-			...generatePathItemObject(route)
-		});
-	}
-	return Object.fromEntries(pathItems);
-}
-function generatePathItemObject(route) {
-	return { [route.method]: generateOperationObject(route) };
-}
-function getSchemaReference(model) {
-	return model.id != null ? { $ref: "#/components/schemas/" + model.id } : generateJsonSchema({
-		model,
-		reference: "openapi"
-	});
+function collectModelDeep(model) {
+	const self = "id" in model && model.id != null ? [[model.id, model]] : [];
+	const nested = collectNestedModels(model);
+	return [...self, ...nested];
 }
-function generateOperationObject(route) {
-	const { id, summary, description, variables, queries, headers, cookies, content, responses } = route;
-	const parameterObjects = [];
-	for (const [name, model] of Object.entries(variables)) parameterObjects.push({
-		in: "path",
-		name,
-		required: true,
-		schema: getSchemaReference(model)
-	});
-	if (queries) for (const [name, model] of Object.entries(queries)) parameterObjects.push({
-		in: "query",
-		name,
-		required: model.kind !== "optional",
-		schema: getSchemaReference(model)
-	});
-	if (headers) for (const [name, model] of Object.entries(headers)) parameterObjects.push({
-		in: "header",
-		name,
-		required: model.kind !== "optional",
-		schema: getSchemaReference(model)
-	});
-	if (cookies) for (const [name, model] of Object.entries(cookies)) parameterObjects.push({
-		in: "cookie",
-		name,
-		required: model.kind !== "optional",
-		schema: getSchemaReference(model)
-	});
-	const responseObjects = /* @__PURE__ */ new Map();
-	if (responses) for (const [name, response] of Object.entries(responses)) responseObjects.set(response.status.toString(), generateResponseObjectFromResponse(name, response));
-	return {
-		operationId: id,
-		summary: summary ?? route.id,
-		description,
-		parameters: parameterObjects,
-		responses: Object.fromEntries(responseObjects),
-		requestBody: content == null ? void 0 : generateRequestBodyObject(content)
-	};
-}
-function generateRequestBodyObject(content) {
-	switch (content.kind) {
-		case "plain-text-content":
-		case "json-content":
-		case "form-content": return { content: { [content.type]: generateMeidaTypeObject(content) } };
-		default: return {
-			description: content.description,
-			content: { [content.type]: generateMeidaTypeObject(content) }
-		};
+function collectNestedModels(model) {
+	switch (model.kind) {
+		case "array":
+		case "set":
+		case "map": return collectModelDeep(model.base);
+		case "record": return Object.values(model.properties).flatMap(collectModelDeep);
+		case "union": return Object.values(model.variants).flatMap(collectModelDeep);
+		case "taggedUnion": return Object.values(model.variants).flatMap(collectModelDeep);
+		default: return [];
 	}
 }
-function generateMeidaTypeObject(content) {
-	switch (content.kind) {
-		case "plain-text-content": return { schema: content.model ? getSchemaReference(content.model) : { type: "string" } };
-		case "plain-text-stream-content": return {
-			schema: {
-				type: "string",
-				format: "binary"
-			},
-			itemSchema: content.model ? getSchemaReference(content.model) : { type: "string" }
-		};
-		case "json-content": return { schema: getSchemaReference(content.model) };
-		case "json-stream-content": return {
-			schema: {
-				type: "string",
-				format: "binary"
-			},
-			itemSchema: getSchemaReference(content.model)
-		};
-		case "binary-stream-content": return {
-			schema: {
-				type: "string",
-				format: "binary"
-			},
-			itemSchema: {
-				type: "string",
-				format: "binary"
+function generatePaths(flatRoutes, registry) {
+	return flatRoutes.reduce((paths, { route, group, fullPath }) => {
+		const existing = paths[fullPath] ?? {};
+		const method = route.method.toLowerCase();
+		return {
+			...paths,
+			[fullPath]: {
+				...existing,
+				[method]: generateOperation(route, group, registry)
 			}
 		};
-		case "form-content": return { schema: getSchemaReference(content.model) };
-	}
+	}, {});
 }
-function generateResponseObjectFromResponse(name, response) {
-	const headerObjects = /* @__PURE__ */ new Map();
-	if (response.headers) for (const [name, model] of Object.entries(response.headers)) headerObjects.set(name, {
-		schema: getSchemaReference(model),
-		required: model.kind !== "optional"
-	});
+function generateOperation(route, group, registry) {
+	const tags = route.tags?.includes(group) ? route.tags : [...route.tags ?? [], group];
 	return {
-		description: response.description ?? name,
-		headers: headerObjects.size > 0 ? Object.fromEntries(headerObjects) : void 0,
-		content: response.content == null ? void 0 : { [response.content.type]: generateMeidaTypeObject(response.content) }
+		summary: route.summary,
+		description: route.description,
+		tags,
+		parameters: generateParameters(route, registry),
+		requestBody: generateRequestBody(route, registry),
+		responses: generateResponses(route.responses, registry)
 	};
 }
-function route(options) {
+function generateParameters(route, registry) {
+	const pathParams = Object.entries(route.variables ?? {}).map(([name, model]) => generateParameter(name, model, "path", true, registry));
+	const queries = route.queries;
+	const headers = route.headers;
+	const queryParams = queries ? Object.entries(queries.properties).map(([name, model]) => generateParameter(name, model, "query", queries.required.includes(name), registry)) : [];
+	const headerParams = headers ? Object.entries(headers.properties).map(([name, model]) => generateParameter(name, model, "header", headers.required.includes(name), registry)) : [];
+	const all = [
+		...pathParams,
+		...queryParams,
+		...headerParams
+	];
+	return all.length > 0 ? all : void 0;
+}
+function generateParameter(name, model, location, required, registry) {
 	return {
-		kind: "http-route",
-		...options
+		name,
+		in: location,
+		required,
+		schema: getSchema(model, registry)
 	};
 }
-function plainText(options) {
-	return {
-		kind: "plain-text-content",
-		...options
-	};
+function generateRequestBody(route, registry) {
+	if (route.body == null || route.body.kind === "null") return void 0;
+	return { content: { [route.contentType ?? "application/json"]: generateMediaType(route.body, registry) } };
 }
-function json(options) {
-	return {
-		kind: "json-content",
-		...options
-	};
+function generateMediaType(model, registry) {
+	return { schema: getSchema(model, registry) };
 }
-function plainTextStream(options) {
-	return {
-		kind: "plain-text-stream-content",
-		...options
-	};
+function generateResponses(responses, registry) {
+	return Object.entries(responses).reduce((acc, [status, response]) => ({
+		...acc,
+		[status]: generateResponseObject(response, registry)
+	}), {});
 }
-function jsonStream(options) {
+function generateResponseObject(response, registry) {
 	return {
-		kind: "json-stream-content",
-		...options
+		description: response.summary ?? "",
+		headers: response.kind !== "binary" && response.headers ? generateResponseHeaders(response.headers, registry) : void 0,
+		content: generateResponseContent(response, registry)
 	};
 }
-function binary(options) {
+function generateResponseHeaders(headers, registry) {
+	return Object.entries(headers.properties).reduce((acc, [name, model]) => ({
+		...acc,
+		[name]: { schema: getSchema(model, registry) }
+	}), {});
+}
+function generateResponseContent(response, registry) {
+	switch (response.kind) {
+		case "json-response": {
+			if (response.body == null) return void 0;
+			const contentType = response.contentType ?? "application/json";
+			const mediaType = { schema: getSchema(response.body, registry) };
+			return { [contentType]: mediaType };
+		}
+		case "stream-response": {
+			if (response.body == null) return void 0;
+			const contentType = response.contentType ?? "application/x-ndjson";
+			const mediaType = {
+				schema: {
+					type: "string",
+					format: "binary"
+				},
+				itemSchema: getSchema(response.body, registry)
+			};
+			return { [contentType]: mediaType };
+		}
+		case "sse-response": {
+			const contentType = response.contentType ?? "text/event-stream";
+			const mediaType = {
+				schema: {
+					type: "string",
+					format: "binary"
+				},
+				itemSchema: response.body ? getSchema(response.body, registry) : { type: "string" }
+			};
+			return { [contentType]: mediaType };
+		}
+		case "binary": return { [response.contentType ?? "application/octet-stream"]: { schema: {
+			type: "string",
+			format: "binary"
+		} } };
+	}
+}
+function getSchema(model, registry) {
+	const ref = registry.getRef(model);
+	return ref ? { $ref: ref } : generateJsonSchema({
+		model,
+		registry
+	}).jsonSchema;
+}
+function buildSecuritySchemes(policy, deployments) {
+	const components = collectSecurityComponents(policy);
+	if (components.length === 0) return { schemes: void 0 };
+	const schemes = {};
+	for (const component of components) switch (component.kind) {
+		case "apikey":
+			schemes[component.id] = toApiKeyScheme(component);
+			break;
+		case "openIdConnect": {
+			const deployment = findDeployment(component, deployments);
+			if (!deployment || deployment.kind !== "openIdConnectDeployment") {
+				console.warn(`[generateOpenapi] Security scheme "${component.id}" (openIdConnect) has no matching deployment, skipping`);
+				break;
+			}
+			schemes[component.id] = toOpenIdConnectScheme(component, deployment);
+			break;
+		}
+	}
+	return { schemes: Object.keys(schemes).length > 0 ? schemes : void 0 };
+}
+function findDeployment(component, deployments) {
+	if (!deployments) return void 0;
+	for (const dep of Object.values(deployments)) if (dep.component.id === component.id) return dep;
+}
+function toApiKeyScheme(component) {
 	return {
-		kind: "binary-stream-content",
-		...options
+		type: "apiKey",
+		name: component.name,
+		in: "header",
+		description: component.description
 	};
 }
-function form(options) {
+function toOpenIdConnectScheme(component, deployment) {
 	return {
-		kind: "form-content",
-		...options
+		type: "openIdConnect",
+		openIdConnectUrl: deployment.issuer.endsWith("/") ? `${deployment.issuer}.well-known/openid-configuration` : `${deployment.issuer}/.well-known/openid-configuration`,
+		description: component.description
 	};
 }
-//#endregion
-//#region src/generator/java.ts
-function generateJavaClass(options) {
-	const { model, package: packageName } = options;
-	switch (model.kind) {
-		case "record": return `
-            package ${packageName};
-
-            import org.jspecify.annotations.NullMarked;
-
-            @NullMarked
-            public record ${model.id}(
-                ${Object.entries(model.properties).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
-            ){
-                ${Object.entries(model.properties).filter(([__dirname, v]) => v.kind === "literal").map(([k, v]) => generateStaticPropertyCode(packageName, k, v)).join(";")}
-            }
-        `;
-		case "union": return `
-            package ${packageName};
-
-            import org.jspecify.annotations.NullMarked;
-            
-            @NullMarked
-            public sealed interface ${model.id}{
-                ${Object.entries(model.variants).map(([k, v]) => generateUnionVariantCode(packageName, model.id, k, v)).join("\n")}
-            }
-        `;
-		case "error": return `
-            package ${packageName};
-
-            import org.jspecify.annotations.NullMarked;
-
-            @NullMarked
-            public record ${model.id}(Context context){
-                ${generateStaticPropertyCode(packageName, "code", literal({ value: model.code }))}
-
-                public ${model.id}(
-                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
-                ){
-                    this(new Context(${getPropertyNames(model.context)}));
-                }
-
-                public record Context(
-                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
-                ){
-                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateStaticPropertyCode(packageName, k, v)).join(";")}
-                }
-            }
-        `;
-		case "enums": return `
-                    
-            package ${packageName};
-
-            import org.jspecify.annotations.NullMarked;
-
-            public enum ${model.id} {
-
-                ${Object.entries(model.variants).map(([k, v]) => `${k}("${v}")`)};
-                
-                private final String value;
-
-                public ${model.id}(String value){
-                    this.value = value;
-                }
-
-                @com.fasterxml.jackson.annotation.JsonValue
-                public String getValue() { 
-                    return value;
-                }
-            }
-        `;
-	}
-}
-function getPropertyNames(properties) {
-	if (properties == null) return "";
-	return Object.keys(properties).join(",");
-}
-function generateUnionVariantCode(packageName, unionId, variantName, variant) {
-	switch (variant.kind) {
-		case "literal": return `
-            record ${variantName}() implements ${unionId} {
-                @com.fasterxml.jackson.annotation.JsonValue
-                ${generateStaticPropertyCode(packageName, "value", variant)}
-            }
-        `;
-		default: return `
-            record ${variantName}(
-                @com.fasterxml.jackson.annotation.JsonCreator
-                @com.fasterxml.jackson.annotation.JsonValue
-                ${generateModelSignature$1(packageName, variant)} value
-            ) implements ${unionId} {}
-        `;
-	}
-}
-function generatePropertyCode(packageName, name, property) {
-	return `${generateModelSignature$1(packageName, property)} ${name}`;
-}
-function generateStaticPropertyCode(packageName, name, property) {
-	return `public ${generateModelSignature$1(packageName, property)} ${name} = ${generateStaticValue$1(property.value)}`;
-}
-function generateStaticValue$1(value) {
-	switch (typeof value) {
-		case "string": return `"${value}"`;
-		case "boolean": return String(value);
-		case "number": return Number.isInteger(value) ? String(value) : value + "d";
-		default: throw Error("Unsupported literal value");
-	}
-}
-function generateModelSignature$1(packageName, model) {
-	switch (model.kind) {
-		case "string": return "String";
-		case "int32": return "int";
-		case "int64": return "long";
-		case "float32": return "float";
-		case "float64": return "double";
-		case "boolean": return "boolean";
-		case "date": return "java.time.LocalDate";
-		case "datetime": return "java.time.LocalDateTime";
-		case "duration": return "java.time.Duration";
-		case "array": return `Array<${generateModelSignature$1(packageName, model.base)}>`;
-		case "set": return `Set<${generateModelSignature$1(packageName, model.base)}>`;
-		case "map": return `Map<String, ${generateModelSignature$1(packageName, model.base)}>`;
-		case "optional": switch (model.base.kind) {
-			case "int32": return "@Nullable Integer";
-			case "int64": return "@Nullable Long";
-			case "float32": return "@Nullable Float";
-			case "float64": return "@Nullable Double";
-			case "boolean": return "@Nullable Boolean";
-			case "optional": return generateModelSignature$1(packageName, model.base);
-			default: return `@Nullable ${generateModelSignature$1(packageName, model.base)}`;
-		}
-		case "literal": switch (typeof model.value) {
-			case "string": return "String";
-			case "boolean": return "boolean";
-			case "number": return Number.isInteger(model.value) ? "int" : "double";
-			default: throw Error("Unsupported literal value");
+function collectSecurityComponents(policy) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const pathItem of Object.values(policy.paths)) {
+		if (!pathItem.pipeline) continue;
+		for (const apply of pathItem.pipeline) if (!seen.has(apply.component.id)) {
+			seen.add(apply.component.id);
+			result.push(apply.component);
 		}
-		default: return packageName + "." + model.id;
 	}
+	return result;
+}
+function applySecurityToPaths(paths, policy) {
+	if (!paths) return void 0;
+	const operationMethods = [
+		"get",
+		"put",
+		"post",
+		"delete",
+		"options",
+		"head",
+		"patch",
+		"trace"
+	];
+	return Object.entries(paths).reduce((acc, [pathKey, pathItem]) => {
+		const securedItem = operationMethods.reduce((methodAcc, method) => {
+			const op = pathItem[method];
+			if (!op) return methodAcc;
+			const requirements = resolveSecurityRequirements(policy, pathKey, method);
+			if (requirements.length === 0) return methodAcc;
+			return {
+				...methodAcc,
+				[method]: {
+					...op,
+					security: requirements
+				}
+			};
+		}, pathItem);
+		return {
+			...acc,
+			[pathKey]: securedItem
+		};
+	}, {});
+}
+function resolveSecurityRequirements(policy, pathKey, method) {
+	const requirements = [];
+	for (const [pattern, pathItem] of Object.entries(policy.paths)) {
+		if (!matchesPath(pattern, pathKey)) continue;
+		const methods = pathItem.methods;
+		if (methods && methods.length > 0 && !methods.includes(method.toUpperCase())) continue;
+		if (!pathItem.pipeline) continue;
+		for (const apply of pathItem.pipeline) requirements.push({ [apply.component.id]: apply.scopes });
+	}
+	return requirements;
 }
-async function formatJava(code) {
+function matchesPath(pattern, path) {
 	try {
-		return await format(code, {
-			parser: "java",
-			plugins: [PrettierJavaPlugin]
-		});
-	} catch (error) {
-		console.error(error);
-		return code;
-	}
-}
-async function generateJavaCodes(options) {
-	const { package: packageName, srcDir, routes = [], models = [] } = options;
-	const codes = /* @__PURE__ */ new Map();
-	const namedModels = collectModelFromRoutes(routes);
-	for (const model of models) for (const [id, subModel] of collectModelDeep(model)) namedModels.set(id, subModel);
-	for (const [id, model] of namedModels) {
-		if (model.kind !== "union" && model.kind !== "record" && model.kind !== "enums" && model.kind !== "error") continue;
-		const path = resolve(srcDir, ...(packageName + "." + id).split("."), ".java");
-		const code = await formatJava(generateJavaClass({
-			package: packageName,
-			model
-		}));
-		codes.set(path, code);
-	}
-	return codes.entries().map(([path, code]) => ({
-		path,
-		code
-	})).toArray();
+		return new RegExp(pattern).test(path);
+	} catch {
+		return false;
+	}
 }
 //#endregion
-//#region src/generator/rust.ts
-function generateRustCode(options) {
-	const { model } = options;
-	switch (model.kind) {
-		case "record": return generateRecordCode(model);
-		case "union": return generateUnionCode(model);
-		case "error": return generateErrorCode(model);
-		case "enums": return generateEnumCode(model);
-	}
-}
-function generateRecordCode(model) {
-	const structName = toPascalCase(model.id || "Unknown");
-	const structFields = Object.entries(model.properties).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generateStructField(k, v));
-	const constFields = Object.entries(model.properties).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateConstField(k, v));
-	const hasConstants = constFields.length > 0;
-	const hasFields = structFields.length > 0;
-	let code = `use serde::Serialize;\n\n`;
-	if (hasConstants && hasFields) {
-		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
-		structFields.forEach((f) => {
-			code += `    ${f};\n`;
+//#region src/codegen/collect.ts
+function collectNamedModels(models, options) {
+	const identifier = options?.identifier ?? pascalCase;
+	const namespace = options?.namespace;
+	return models.reduce((acc, model) => {
+		if (model.kind === "record") return [...acc, toRecordDescriptor(model, identifier, namespace)];
+		if (model.kind === "enums") return [...acc, toEnumsDescriptor(model, identifier, namespace)];
+		if (model.kind === "union") return [...acc, {
+			kind: "union",
+			originalId: model.id,
+			identifier: identifier(model.id),
+			namespace,
+			title: model.title,
+			description: model.description,
+			deprecated: model.deprecated,
+			examples: model.examples,
+			variants: model.variants
+		}];
+		if (model.kind === "taggedUnion") return [...acc, {
+			kind: "taggedUnion",
+			originalId: model.id,
+			identifier: identifier(model.id),
+			namespace,
+			title: model.title,
+			description: model.description,
+			deprecated: model.deprecated,
+			examples: model.examples,
+			variants: model.variants,
+			variantKey: model.variantKey,
+			payloadKey: model.payloadKey
+		}];
+		return acc;
+	}, []);
+}
+function toRecordDescriptor(model, identifier, namespace) {
+	return {
+		kind: "record",
+		originalId: model.id,
+		identifier: identifier(model.id),
+		namespace,
+		title: model.title,
+		description: model.description,
+		deprecated: "deprecated" in model ? model.deprecated : void 0,
+		examples: model.examples,
+		fields: Object.entries(model.properties).map(([name, propModel]) => ({
+			name,
+			model: propModel,
+			required: model.required.includes(name),
+			title: propModel.title,
+			description: propModel.description,
+			deprecated: propModel.deprecated
+		}))
+	};
+}
+function toEnumsDescriptor(model, identifier, namespace) {
+	return {
+		kind: "enums",
+		originalId: model.id,
+		identifier: identifier(model.id),
+		namespace,
+		title: model.title,
+		description: model.description,
+		values: model.variants
+	};
+}
+function joinPath(basePath, routePath) {
+	if (!basePath) return routePath;
+	return `${basePath.endsWith("/") ? basePath.slice(0, -1) : basePath}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
+}
+function collectOperations(routers) {
+	return routers.flatMap((routerModel) => {
+		const basePath = routerModel.basePath ?? "";
+		return Object.entries(routerModel.routes).map(([id, route]) => {
+			const queries = {};
+			if (route.queries) for (const [name, propModel] of Object.entries(route.queries.properties)) queries[name] = {
+				model: propModel,
+				name,
+				required: route.queries.required.includes(name)
+			};
+			const headers = {};
+			if (route.headers) for (const [name, propModel] of Object.entries(route.headers.properties)) headers[name] = {
+				model: propModel,
+				name,
+				required: route.headers.required.includes(name)
+			};
+			const pathVariables = {};
+			if (route.variables) for (const [name, model] of Object.entries(route.variables)) pathVariables[name] = {
+				model,
+				name
+			};
+			const responses = {};
+			const responseKinds = {};
+			for (const [status, resp] of Object.entries(route.responses)) {
+				responses[Number(status)] = "body" in resp && resp.body != null ? resp.body : null;
+				responseKinds[Number(status)] = resp.kind;
+			}
+			return {
+				id,
+				group: routerModel.name,
+				method: route.method,
+				path: joinPath(basePath, route.path),
+				summary: route.summary,
+				description: route.description,
+				tags: route.tags,
+				requestModel: route.body ?? null,
+				responses,
+				responseKinds,
+				pathVariables,
+				queries,
+				headers
+			};
 		});
-		code += `}\n\n`;
-		code += `impl ${structName} {\n`;
-		code += `    pub const CODE: &'static str = "${model.id}";\n`;
-		constFields.forEach((f) => {
-			code += `    pub ${f};\n`;
+	});
+}
+function collectSchemaMap(ops) {
+	const all = collectAll(ops);
+	const map = /* @__PURE__ */ new Map();
+	for (const m of all) {
+		if ("id" in m && map.has(m.id)) continue;
+		if (m.kind === "record") map.set(m.id, {
+			kind: "record",
+			fields: Object.entries(m.properties).map(([name, p]) => ({
+				name,
+				model: p,
+				required: m.required.includes(name)
+			}))
 		});
-		code += `}\n`;
-	} else if (hasFields) {
-		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
-		structFields.forEach((f) => {
-			code += `    ${f},\n`;
+		else if (m.kind === "enums") map.set(m.id, {
+			kind: "enums",
+			variants: m.variants
 		});
-		code += `}\n`;
-	} else if (hasConstants) {
-		code += `#[derive(Serialize)]\npub struct ${structName};\n\n`;
-		code += `impl ${structName} {\n`;
-		code += `    pub const CODE: &'static str = "${model.id}";\n`;
-		constFields.forEach((f) => {
-			code += `    pub ${f};\n`;
+		else if (m.kind === "union") map.set(m.id, {
+			kind: "union",
+			unionVariants: m.variants
 		});
-		code += `}\n`;
-	}
-	return code;
-}
-function generateUnionCode(model) {
-	const enumName = toPascalCase(model.id || "Unknown");
-	let code = `use serde::Serialize;\n\n`;
-	code += `#[derive(Serialize)]\n#[serde(tag = "type", content = "value")]\npub enum ${enumName} {\n`;
-	Object.entries(model.variants).forEach(([k, v]) => {
-		const variantName = toPascalCase(k);
-		if (v.kind === "literal") code += `    ${variantName},\n`;
-		else {
-			const variantType = generateModelSignature(v);
-			code += `    ${variantName}(${variantType}),\n`;
-		}
-	});
-	code += `}\n`;
-	return code;
-}
-function generateErrorCode(model) {
-	const structName = toPascalCase(model.id || "Unknown");
-	const contextFields = Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generateStructField(k, v));
-	const constFields = Object.entries(model.context ?? {}).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateConstField(k, v));
-	let code = `use serde::Serialize;\n\n`;
-	if (contextFields.length > 0 || constFields.length > 0) {
-		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
-		code += `    pub code: &'static str,\n`;
-		if (contextFields.length > 0) code += `    pub context: ${structName}Context,\n`;
-		code += `}\n\n`;
-		if (contextFields.length > 0) {
-			code += `#[derive(Serialize)]\npub struct ${structName}Context {\n`;
-			contextFields.forEach((f) => {
-				code += `    ${f};\n`;
-			});
-			code += `}\n\n`;
-		}
-		code += `impl ${structName} {\n`;
-		code += `    pub const CODE: &'static str = "${model.code}";\n`;
-		constFields.forEach((f) => {
-			code += `    pub ${f};\n`;
+		else if (m.kind === "taggedUnion") map.set(m.id, {
+			kind: "taggedUnion",
+			unionVariants: m.variants,
+			variantKey: m.variantKey,
+			payloadKey: m.payloadKey
 		});
-		code += `}\n`;
-	} else {
-		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
-		code += `    pub code: &'static str,\n`;
-		code += `}\n\n`;
-		code += `impl ${structName} {\n`;
-		code += `    pub const CODE: &'static str = "${model.code}";\n`;
-		code += `}\n`;
-	}
-	return code;
-}
-function generateEnumCode(model) {
-	const enumName = toPascalCase(model.id || "Unknown");
-	let code = `use serde::Serialize;\n\n`;
-	code += `#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]\npub enum ${enumName} {\n`;
-	Object.entries(model.variants).forEach(([k, v]) => {
-		const variantName = toUpperSnakeCase(k);
-		code += `    #[serde(rename = "${v}")]\n`;
-		code += `    ${variantName},\n`;
-	});
-	code += `}\n`;
-	return code;
+	}
+	return map;
+}
+function collectAll(ops) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const add = (m) => {
+		if (m == null || seen.has(m)) return;
+		seen.add(m);
+		out.push(m);
+		if (m.kind === "array" || m.kind === "set" || m.kind === "map") add(m.base);
+		if (m.kind === "record") Object.values(m.properties).forEach((v) => add(v));
+		if (m.kind === "union" || m.kind === "taggedUnion") Object.values(m.variants).forEach((v) => add(v));
+	};
+	for (const op of ops) {
+		add(op.requestModel);
+		for (const v of Object.values(op.responses)) add(v);
+		for (const v of Object.values(op.pathVariables)) add(v.model);
+		for (const v of Object.values(op.queries)) add(v.model);
+		for (const v of Object.values(op.headers)) add(v.model);
+	}
+	return out;
 }
-function generateStructField(name, property) {
-	return `pub ${toSnakeCase(name)}: ${generateModelSignature(property)}`;
+function resolveNamedRoot(m) {
+	switch (m.kind) {
+		case "record":
+		case "enums":
+		case "union":
+		case "taggedUnion": return m;
+		case "array":
+		case "set":
+		case "map": return resolveNamedRoot(m.base);
+		default: return null;
+	}
 }
-function generateConstField(name, property) {
-	return `const ${toUpperSnakeCase(name)}: ${generateModelSignature(property)} = ${generateStaticValue(property.value)}`;
+//#endregion
+//#region src/codegen/json-schema.ts
+function mergeJsonSchemas(schemas) {
+	const entries = Object.entries(schemas);
+	const registry = entries.reduce((reg, [id, model]) => reg.add(id, model), createJsonSchemaRegistry());
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$defs: entries.reduce((acc, [id, model]) => {
+			const { jsonSchema } = generateJsonSchema({
+				model,
+				registry
+			});
+			return typeof jsonSchema === "object" && jsonSchema != null ? {
+				...acc,
+				[id]: jsonSchema
+			} : acc;
+		}, {})
+	};
 }
-function generateStaticValue(value) {
-	switch (typeof value) {
-		case "string": return `"${value}"`;
-		case "boolean": return String(value);
-		case "number": return Number.isInteger(value) ? String(value) : `${value}.0`;
-		default: throw Error("Unsupported literal value");
+//#endregion
+//#region src/codegen/hono-server.ts
+function generateHonoServer(options) {
+	const { routers, identifier = pascalCase, namespace } = options;
+	const operations = collectOperations(routers);
+	const schemaMap = collectSchemaMap(operations);
+	const files = {};
+	files["models.ts"] = generateModels$1(schemaMap, identifier, namespace);
+	for (const operation of operations) files[`${camelCase(operation.id)}.ts`] = generateOpFile(operation, schemaMap, identifier, namespace);
+	files["index.ts"] = generateIndex(operations, identifier);
+	return files;
+}
+function generateModels$1(schemaMap, identifier, namespace) {
+	const lines = [];
+	lines.push(`import { z } from "zod"`);
+	lines.push("");
+	for (const [id, schemaInfo] of schemaMap) {
+		const schemaName = camelCase(id) + "Schema";
+		const tsName = identifier(id);
+		switch (schemaInfo.kind) {
+			case "record":
+				lines.push(`export const ${schemaName} = z.object({`);
+				for (const field of schemaInfo.fields) lines.push(`  ${field.name}: ${toZod$1(field.model, schemaMap)}${field.required ? "" : ".optional()"},`);
+				lines.push(`})`);
+				lines.push("");
+				lines.push(`export interface ${tsName} {`);
+				for (const field of schemaInfo.fields) lines.push(`  ${field.name}${field.required ? "" : "?"}: ${toTs$1(field.model, schemaMap, identifier, namespace)};`);
+				lines.push(`}`);
+				lines.push("");
+				break;
+			case "enums":
+				lines.push(`export const ${schemaName} = z.enum(${JSON.stringify(Object.values(schemaInfo.variants))})`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			case "union": {
+				const unionItems = Object.entries(schemaInfo.unionVariants).map(([, v]) => toZod$1(v, schemaMap)).join(", ");
+				lines.push(`export const ${schemaName} = z.union([${unionItems}])`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			}
+			case "taggedUnion": {
+				const variantKey = schemaInfo.variantKey;
+				const payloadKey = schemaInfo.payloadKey;
+				const unionItems = Object.entries(schemaInfo.unionVariants).map(([key, v]) => `z.object({ ${JSON.stringify(variantKey)}: z.literal(${JSON.stringify(key)}), ${JSON.stringify(payloadKey)}: ${toZod$1(v, schemaMap)} })`);
+				lines.push(`export const ${schemaName} = z.discriminatedUnion(${JSON.stringify(variantKey)}, [${unionItems.join(", ")}])`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			}
+		}
 	}
-}
-function generateModelSignature(model) {
-	switch (model.kind) {
-		case "string": return "String";
-		case "int32": return "i32";
-		case "int64": return "i64";
-		case "float32": return "f32";
-		case "float64": return "f64";
-		case "boolean": return "bool";
-		case "date": return "chrono::NaiveDate";
-		case "datetime": return "chrono::DateTime<chrono::Utc>";
-		case "duration": return "serde_json::Value";
-		case "array": return `Vec<${generateModelSignature(model.base)}>`;
-		case "set": return `Vec<${generateModelSignature(model.base)}>`;
-		case "map": return `std::collections::HashMap<String, ${generateModelSignature(model.base)}>`;
-		case "optional": return `Option<${generateModelSignature(model.base)}>`;
-		case "literal": switch (typeof model.value) {
-			case "string": return "&str";
-			case "boolean": return "bool";
-			case "number": return Number.isInteger(model.value) ? "i64" : "f64";
-			default: throw Error("Unsupported literal value");
+	return lines.join("\n");
+}
+function generateOpFile(operation, schemaMap, identifier, namespace) {
+	const lines = [];
+	const OperationName = pascalCase(operation.id);
+	const operationName = camelCase(operation.id);
+	const hasBody = operation.requestModel != null && operation.requestModel.kind !== "null";
+	const hasParams = Object.keys(operation.pathVariables).length > 0;
+	const hasQuery = Object.keys(operation.queries).length > 0;
+	const hasHeaders = Object.keys(operation.headers).length > 0;
+	if (hasParams || hasQuery || hasHeaders) lines.push(`import { z } from "zod"`);
+	const schemaImports = [];
+	if (hasBody && "id" in operation.requestModel) {
+		const root = resolveNamedRoot(operation.requestModel);
+		if (root && schemaMap.has(root.id)) schemaImports.push(camelCase(root.id) + "Schema");
+	}
+	const typeImports = [];
+	if (hasBody && "id" in operation.requestModel) {
+		const root = resolveNamedRoot(operation.requestModel);
+		if (root) {
+			const typeName = identifier(root.id);
+			if (schemaMap.has(root.id) && !typeImports.includes(typeName)) typeImports.push(typeName);
 		}
-		default: return model.id ? toPascalCase(model.id) : "()";
 	}
+	for (const responseModel of Object.values(operation.responses)) {
+		if (responseModel == null) continue;
+		const root = resolveNamedRoot(responseModel);
+		if (root) {
+			const typeName = identifier(root.id);
+			if (schemaMap.has(root.id) && !typeImports.includes(typeName)) typeImports.push(typeName);
+		}
+	}
+	const allImports = [...new Set([...schemaImports, ...typeImports])];
+	lines.push(`import type { Context } from "hono"`);
+	if (allImports.length > 0 || schemaImports.length > 0) {
+		const parts = [];
+		if (typeImports.length > 0) parts.push(typeImports.join(", "));
+		if (schemaImports.length > 0) parts.push(schemaImports.join(", "));
+		lines.push(`import { ${parts.join(", ")} } from "./models"`);
+	}
+	lines.push("");
+	if (hasParams) {
+		const fields = Object.entries(operation.pathVariables).map(([key, value]) => `  ${key}: ${toZod$1(value.model, schemaMap)},`);
+		lines.push(`const ${operationName}Params = z.object({`);
+		lines.push(...fields);
+		lines.push(`})`);
+		lines.push("");
+	}
+	if (hasQuery) {
+		const fields = Object.entries(operation.queries).map(([key, query]) => `  ${key}: ${toZod$1(query.model, schemaMap)}${query.required ? "" : ".optional()"},`);
+		lines.push(`const ${operationName}Query = z.object({`);
+		lines.push(...fields);
+		lines.push(`})`);
+		lines.push("");
+	}
+	if (hasHeaders) {
+		const fields = Object.entries(operation.headers).map(([key, header]) => `  "${key}": ${toZod$1(header.model, schemaMap)}${header.required ? "" : ".optional()"},`);
+		lines.push(`const ${operationName}Headers = z.object({`);
+		lines.push(...fields);
+		lines.push(`})`);
+		lines.push("");
+	}
+	const requestFields = [];
+	if (hasParams) {
+		const field = Object.entries(operation.pathVariables).map(([key, value]) => `${key}: ${toTs$1(value.model, schemaMap, identifier, namespace)}`).join("; ");
+		requestFields.push(`params: { ${field} }`);
+	}
+	if (hasQuery) {
+		const field = Object.entries(operation.queries).map(([key, query]) => `${key}${query.required ? "" : "?"}: ${toTs$1(query.model, schemaMap, identifier, namespace)}`).join("; ");
+		requestFields.push(`query: { ${field} }`);
+	}
+	if (hasHeaders) {
+		const field = Object.entries(operation.headers).map(([key, header]) => `"${key}"${header.required ? "" : "?"}: ${toTs$1(header.model, schemaMap, identifier, namespace)}`).join("; ");
+		requestFields.push(`headers: { ${field} }`);
+	}
+	if (hasBody) requestFields.push(`body: ${toTs$1(operation.requestModel, schemaMap, identifier, namespace)}`);
+	lines.push(`export interface ${OperationName}Request {`);
+	for (const field of requestFields) lines.push(`  ${field}`);
+	lines.push(`}`);
+	lines.push("");
+	const responseEntries = Object.entries(operation.responses);
+	const responseKind = (status) => operation.responseKinds[Number(status)] ?? "json-response";
+	const responseBodyField = (kind, model) => {
+		if (model == null) {
+			if (kind === "binary") return "body: Blob";
+			return null;
+		}
+		if (kind === "stream-response" || kind === "sse-response") return `stream: ReadableStream<${toTs$1(model, schemaMap, identifier, namespace)}>`;
+		if (kind === "binary") return "body: Blob";
+		return `body: ${toTs$1(model, schemaMap, identifier, namespace)}`;
+	};
+	if (responseEntries.length === 1) {
+		const [status, responseModel] = responseEntries[0];
+		const bodyField = responseBodyField(responseKind(status), responseModel);
+		if (bodyField != null) lines.push(`export type ${OperationName}Response = { status: ${status}; ${bodyField} }`);
+		else lines.push(`export type ${OperationName}Response = { status: ${status} }`);
+	} else {
+		lines.push(`export type ${OperationName}Response =`);
+		const parts = responseEntries.map(([status, responseModel]) => {
+			const bodyField = responseBodyField(responseKind(status), responseModel);
+			if (bodyField != null) return `  | { status: ${status}; ${bodyField} }`;
+			return `  | { status: ${status} }`;
+		});
+		lines.push(parts.join("\n"));
+	}
+	lines.push("");
+	if (requestFields.length > 0) lines.push(`export type ${OperationName}Handler = (req: ${OperationName}Request) => Promise<${OperationName}Response>`);
+	else lines.push(`export type ${OperationName}Handler = () => Promise<${OperationName}Response>`);
+	lines.push("");
+	lines.push(`export function ${operationName}(handler: ${OperationName}Handler) {`);
+	lines.push(`  return {`);
+	lines.push(`    method: "${operation.method.toUpperCase()}",`);
+	lines.push(`    path: "${toHonoPath(operation.path)}",`);
+	lines.push(`    async handler(context: Context): Promise<Response> {`);
+	const requestArgs = [];
+	if (hasParams) {
+		lines.push(`      const params = ${operationName}Params.parse(context.req.param())`);
+		requestArgs.push("params");
+	}
+	if (hasQuery) {
+		lines.push(`      const query = ${operationName}Query.parse(context.req.query())`);
+		requestArgs.push("query");
+	}
+	if (hasHeaders) {
+		const headerParts = Object.keys(operation.headers).map((key) => `        "${key}": context.req.header("${key}"),`);
+		lines.push(`      const headers = ${operationName}Headers.parse({`);
+		lines.push(...headerParts);
+		lines.push(`      })`);
+		requestArgs.push("headers");
+	}
+	if (hasBody) {
+		const schemaName = camelCase(operation.requestModel.id) + "Schema";
+		lines.push(`      const body = ${schemaName}.parse(await context.req.json())`);
+		requestArgs.push("body");
+	}
+	if (requestArgs.length > 0) lines.push(`      const result = await handler({ ${requestArgs.join(", ")} })`);
+	else lines.push(`      const result = await handler()`);
+	lines.push(`      switch (result.status) {`);
+	for (const [status, responseModel] of Object.entries(operation.responses)) {
+		const kind = operation.responseKinds[Number(status)] ?? "json-response";
+		if (responseModel != null) if (kind === "json-response") lines.push(`        case ${status}: return new Response(JSON.stringify(result.body), { status: ${status}, headers: { "Content-Type": "application/json" } })`);
+		else if (kind === "binary") lines.push(`        case ${status}: return new Response(result.body, { status: ${status}, headers: { "Content-Type": "${contentTypeForKind(kind)}" } })`);
+		else lines.push(`        case ${status}: return new Response(result.stream, { status: ${status}, headers: { "Content-Type": "${contentTypeForKind(kind)}" } })`);
+		else if (kind === "binary") lines.push(`        case ${status}: return new Response(result.body, { status: ${status}, headers: { "Content-Type": "${contentTypeForKind(kind)}" } })`);
+		else lines.push(`        case ${status}: return new Response(null, { status: ${status} })`);
+	}
+	lines.push(`        default: return new Response(JSON.stringify({ message: \`Unexpected response status \${(result as { status: number }).status}\` }), { status: 500, headers: { "Content-Type": "application/json" } })`);
+	lines.push(`      }`);
+	lines.push(`    },`);
+	lines.push(`  }`);
+	lines.push(`}`);
+	return lines.join("\n");
+}
+function generateIndex(operations, _identifier) {
+	const lines = [];
+	lines.push(`import { Hono } from "hono"`);
+	lines.push("");
+	for (const operation of operations) {
+		const operationName = camelCase(operation.id);
+		const OperationName = pascalCase(operation.id);
+		lines.push(`import { ${operationName}, type ${OperationName}Handler, type ${OperationName}Request, type ${OperationName}Response } from "./${operationName}"`);
+		lines.push(`export type { ${OperationName}Handler, ${OperationName}Request, ${OperationName}Response }`);
+	}
+	lines.push("");
+	const groups = groupBy$1(operations, (operation) => operation.group);
+	lines.push(`export function mountRoutes(`);
+	lines.push(`  app: Hono,`);
+	lines.push(`  handlers: {`);
+	for (const [group, groupOps] of Object.entries(groups)) {
+		lines.push(`    ${camelCase(group)}: {`);
+		for (const operation of groupOps) {
+			const operationName = camelCase(operation.id);
+			lines.push(`      ${operationName}: ${pascalCase(operation.id)}Handler,`);
+		}
+		lines.push(`    },`);
+	}
+	lines.push(`  },`);
+	lines.push(`) {`);
+	for (const [group, groupOps] of Object.entries(groups)) {
+		lines.push(`  // ── ${group} ──`);
+		for (const operation of groupOps) {
+			const operationName = camelCase(operation.id);
+			lines.push(`  const ${operationName}Def = ${operationName}(handlers.${camelCase(group)}.${operationName})`);
+			lines.push(`  app.on(${operationName}Def.method, ${operationName}Def.path, ${operationName}Def.handler)`);
+		}
+		lines.push("");
+	}
+	lines.push(`}`);
+	lines.push("");
+	return lines.join("\n");
+}
+function groupBy$1(items, keyFn) {
+	const map = {};
+	for (const item of items) {
+		const key = keyFn(item);
+		if (!map[key]) map[key] = [];
+		map[key].push(item);
+	}
+	return map;
 }
-function toPascalCase(str) {
-	return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c ? c.toUpperCase() : "");
+function toHonoPath(path) {
+	return path.replace(/\{(\w+)\}/g, ":$1");
 }
-function toSnakeCase(str) {
-	return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").toLowerCase();
+function contentTypeForKind(kind) {
+	switch (kind) {
+		case "binary": return "application/octet-stream";
+		case "stream-response": return "application/x-ndjson";
+		case "sse-response": return "text/event-stream";
+		default: return "application/json";
+	}
 }
-function toUpperSnakeCase(str) {
-	return toSnakeCase(str).toUpperCase();
+function toZod$1(model, schemaMap) {
+	switch (model.kind) {
+		case "int32": return "z.coerce.number().int()";
+		case "float32":
+		case "float64": return "z.coerce.number()";
+		case "boolean": return "z.coerce.boolean()";
+		case "string": return "z.string()";
+		case "datetime": return "z.string().datetime()";
+		case "date": return "z.string().date()";
+		case "duration": return "z.string()";
+		case "literal": return `z.literal(${JSON.stringify(model.value)})`;
+		case "null": return "z.null()";
+		case "array": return `${toZod$1(model.base, schemaMap)}.array()`;
+		case "set": return `${toZod$1(model.base, schemaMap)}.array()`;
+		case "map": return `z.record(z.string(), ${toZod$1(model.base, schemaMap)})`;
+		case "enums": return `z.enum(${JSON.stringify(Object.values(model.variants))})`;
+		case "record": return schemaMap.get(model.id)?.fields ? camelCase(model.id) + "Schema" : "z.unknown()";
+		case "union":
+			if (schemaMap.get(model.id)?.unionVariants) return camelCase(model.id) + "Schema";
+			return `z.union([${Object.values(model.variants).map((v) => toZod$1(v, schemaMap)).join(", ")}])`;
+		case "taggedUnion": {
+			if (schemaMap.get(model.id)?.unionVariants) return camelCase(model.id) + "Schema";
+			const unionItems = Object.entries(model.variants).map(([key, v]) => `z.object({ ${JSON.stringify(model.variantKey)}: z.literal(${JSON.stringify(key)}), ${JSON.stringify(model.payloadKey)}: ${toZod$1(v, schemaMap)} })`);
+			return `z.discriminatedUnion(${JSON.stringify(model.variantKey)}, [${unionItems.join(", ")}])`;
+		}
+		default: return "z.unknown()";
+	}
 }
-async function formatRust(code) {
-	try {
-		return await format(code, {
-			parser: "jinx-rust",
-			plugins: [PrettierRustPlugin]
-		});
-	} catch (error) {
-		console.error(error);
-		return code;
-	}
-}
-async function generateRustCodes(options) {
-	const { module_name, srcDir, routes = [], models = [] } = options;
-	const codes = /* @__PURE__ */ new Map();
-	const namedModels = collectModelFromRoutes(routes);
-	for (const model of models) for (const [id, subModel] of collectModelDeep(model)) namedModels.set(id, subModel);
-	for (const [id, model] of namedModels) {
-		if (model.kind !== "union" && model.kind !== "record" && model.kind !== "enums" && model.kind !== "error") continue;
-		const fullname = module_name + "::" + toSnakeCase(id);
-		const path = resolve(srcDir, ...fullname.split("::"), ".rs");
-		const code = await formatRust(generateRustCode({
-			module_name: fullname,
-			model
-		}));
-		codes.set(path, code);
-	}
-	return codes.entries().map(([path, code]) => ({
-		path,
-		code
-	})).toArray();
+function toTs$1(model, schemaMap, identifier, namespace) {
+	switch (model.kind) {
+		case "int32":
+		case "float32":
+		case "float64": return "number";
+		case "boolean": return "boolean";
+		case "string":
+		case "datetime":
+		case "date":
+		case "duration": return "string";
+		case "literal": return JSON.stringify(model.value);
+		case "null": return "null";
+		case "array":
+		case "set": return `${toTs$1(model.base, schemaMap, identifier, namespace)}[]`;
+		case "map": return `Record<string, ${toTs$1(model.base, schemaMap, identifier, namespace)}>`;
+		case "enums":
+			if (schemaMap.get(model.id)?.variants) return identifier(model.id);
+			return Object.values(model.variants).map((v) => JSON.stringify(v)).join(" | ");
+		case "record": return schemaMap.get(model.id)?.fields ? identifier(model.id) : "unknown";
+		case "union":
+		case "taggedUnion":
+			if (schemaMap.get(model.id)?.unionVariants) return identifier(model.id);
+			return Object.values(model.variants).map((v) => toTs$1(v, schemaMap, identifier, namespace)).join(" | ");
+		default: return "unknown";
+	}
 }
 //#endregion
-//#region src/type-system/serialize.ts
-function deserialize(model, json) {
-	return deserializeInner(model, JSON.parse(json));
-}
-function deserializeInner(model, value) {
-	const success = (value) => ({
-		isSuccess: true,
-		value
-	});
-	if (model.kind === "string") {
-		if (typeof value === "string") return success(value);
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "boolean") {
-		if (typeof value === "boolean") return success(value);
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "int32" || model.kind === "float32" || model.kind === "float64") {
-		if (typeof value === "number") return success(value);
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "int64") {
-		if (typeof value === "string") try {
-			return success(BigInt(value));
-		} catch {
-			return deserializeFailed(model, value);
+//#region src/codegen/ts-client.ts
+function generateTsClient(options) {
+	const { routers, identifier = pascalCase, namespace } = options;
+	const operations = collectOperations(routers);
+	const schemaMap = collectSchemaMap(operations);
+	const files = {};
+	files["models.ts"] = generateModels(schemaMap, identifier, namespace);
+	for (const operation of operations) files[`${camelCase(operation.id)}.ts`] = generateClientFn(operation, schemaMap, identifier, namespace);
+	files["index.ts"] = generateClientIndex(operations, identifier);
+	return files;
+}
+function generateModels(schemaMap, identifier, namespace) {
+	const lines = [];
+	lines.push(`import { z } from "zod"`);
+	lines.push("");
+	for (const [id, schemaInfo] of schemaMap) {
+		const schemaName = camelCase(id) + "Schema";
+		const tsName = identifier(id);
+		switch (schemaInfo.kind) {
+			case "record":
+				lines.push(`export const ${schemaName} = z.object({`);
+				for (const f of schemaInfo.fields) lines.push(`  ${f.name}: ${toZod(f.model, schemaMap)}${f.required ? "" : ".optional()"},`);
+				lines.push(`})`);
+				lines.push("");
+				lines.push(`export interface ${tsName} {`);
+				for (const f of schemaInfo.fields) lines.push(`  ${f.name}${f.required ? "" : "?"}: ${toTs(f.model, schemaMap, identifier, namespace)};`);
+				lines.push(`}`);
+				lines.push("");
+				break;
+			case "enums":
+				lines.push(`export const ${schemaName} = z.enum(${JSON.stringify(Object.values(schemaInfo.variants))})`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			case "union": {
+				const items = Object.entries(schemaInfo.unionVariants).map(([, v]) => toZod(v, schemaMap)).join(", ");
+				lines.push(`export const ${schemaName} = z.union([${items}])`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			}
+			case "taggedUnion": {
+				const vk = schemaInfo.variantKey;
+				const pk = schemaInfo.payloadKey;
+				const items = Object.entries(schemaInfo.unionVariants).map(([key, v]) => `z.object({ ${JSON.stringify(vk)}: z.literal(${JSON.stringify(key)}), ${JSON.stringify(pk)}: ${toZod(v, schemaMap)} })`);
+				lines.push(`export const ${schemaName} = z.discriminatedUnion(${JSON.stringify(vk)}, [${items.join(", ")}])`);
+				lines.push(`export type ${tsName} = z.infer<typeof ${schemaName}>`);
+				lines.push("");
+				break;
+			}
 		}
-		return deserializeFailed(model, value);
 	}
-	if (model.kind === "date" || model.kind === "datetime") {
-		if (typeof value === "string") try {
-			return success(Temporal.Instant.from(value));
-		} catch {
-			return deserializeFailed(model, value);
+	return lines.join("\n");
+}
+function generateClientFn(operation, schemaMap, identifier, namespace) {
+	const lines = [];
+	const functionName = camelCase(operation.id);
+	const OperationName = pascalCase(operation.id);
+	const hasBody = operation.requestModel != null && operation.requestModel.kind !== "null";
+	const hasParams = Object.keys(operation.pathVariables).length > 0;
+	const hasQuery = Object.keys(operation.queries).length > 0;
+	const hasHeaders = Object.keys(operation.headers).length > 0;
+	const typeImports = [];
+	const addNamedRef = (model) => {
+		const root = resolveNamedRoot(model);
+		if (root) {
+			const typeName = identifier(root.id);
+			if (schemaMap.has(root.id) && !typeImports.includes(typeName)) typeImports.push(typeName);
 		}
-		return deserializeFailed(model, value);
+	};
+	if (hasBody) addNamedRef(operation.requestModel);
+	for (const responseModel of Object.values(operation.responses)) if (responseModel != null) addNamedRef(responseModel);
+	const okStatus = Object.keys(operation.responses).find((s) => Number(s) >= 200 && Number(s) < 300);
+	const okModel = okStatus ? operation.responses[Number(okStatus)] : null;
+	const okKind = okStatus ? operation.responseKinds[Number(okStatus)] ?? "json-response" : "json-response";
+	const isStreamLike = okKind === "stream-response" || okKind === "sse-response" || okKind === "binary";
+	const okSchema = okModel ? resolveZodSchema(okModel, schemaMap) : null;
+	const allModelImports = [...typeImports];
+	if (okSchema && !isStreamLike) {
+		const schemaRefs = collectSchemaRefs(okModel, schemaMap);
+		for (const ref of schemaRefs) if (!allModelImports.includes(ref)) allModelImports.push(ref);
 	}
-	if (model.kind === "duration") {
-		if (typeof value === "string") try {
-			return success(Temporal.Duration.from(value));
-		} catch {
-			return deserializeFailed(model, value);
-		}
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "optional") return value == null ? success(void 0) : deserializeInner(model.base, value);
-	if (model.kind === "literal") {
-		if (model.value === value) return success(value);
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "array") {
-		if (typeof value === "object" && Array.isArray(value)) return success(value.map((o) => deserializeInner(model.base, o)));
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "set") {
-		if (typeof value === "object" && Array.isArray(value)) return success(new Set(value.map((o) => deserializeInner(model.base, o))));
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "map") {
-		if (typeof value === "object" && !Array.isArray(value)) {
-			const properties = /* @__PURE__ */ new Map();
-			for (const key in value) {
-				const result = deserializeInner(model.base, value[key]);
-				if (result.isSuccess) properties.set(key, result.value);
-				else return result;
-			}
-			return success(properties);
-		}
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "enums") {
-		if (typeof value === "string" && Object.values(model.variants).includes(value)) return success(value);
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "record") {
-		if (typeof value === "object" && !Array.isArray(value)) {
-			const properties = /* @__PURE__ */ new Map();
-			for (const key in model.properties) {
-				const result = deserializeInner(model.properties[key], value[key]);
-				if (result.isSuccess) properties.set(key, result.value);
-				else return deserializeFailed(model, value);
-			}
-			return success(Object.fromEntries(properties));
+	if (allModelImports.length > 0) {
+		lines.push(`import { ${allModelImports.join(", ")} } from "./models"`);
+		lines.push("");
+	}
+	const requestFields = [];
+	for (const [n, v] of Object.entries(operation.pathVariables)) requestFields.push(`${n}: ${toTs(v.model, schemaMap, identifier, namespace)}`);
+	for (const [n, q] of Object.entries(operation.queries)) {
+		const required = q.required ? "" : "?";
+		requestFields.push(`${n}${required}: ${toTs(q.model, schemaMap, identifier, namespace)}`);
+	}
+	if (hasBody) requestFields.push(`body: ${toTs(operation.requestModel, schemaMap, identifier, namespace)}`);
+	if (hasHeaders) {
+		const field = Object.entries(operation.headers).map(([key, header]) => `"${key}"${header.required ? "" : "?"}: ${toTs(header.model, schemaMap, identifier, namespace)}`).join("; ");
+		requestFields.push(`headers?: { ${field} } & Record<string, string>`);
+	} else requestFields.push("headers?: Record<string, string>");
+	requestFields.push("baseUrl?: string");
+	lines.push(`export interface ${OperationName}Request {`);
+	for (const field of requestFields) lines.push(`  ${field}`);
+	lines.push(`}`);
+	lines.push("");
+	const responseEntries = Object.entries(operation.responses);
+	const responseKind = (status) => operation.responseKinds[Number(status)] ?? "json-response";
+	const responseBodyField = (kind, responseModel) => {
+		if (responseModel == null) {
+			if (kind === "binary") return "body: Blob";
+			return null;
 		}
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "union") {
-		if (typeof value === "object" && !Array.isArray(value)) {
-			const variantKeys = Object.keys(model.variants);
-			for (const key of variantKeys) if (key in value) {
-				const result = deserializeInner(model.variants[key], value[key]);
-				if (result.isSuccess) return success({ [key]: result.value });
-			}
+		if (kind === "stream-response" || kind === "sse-response") return `stream: ReadableStream<${toTs(responseModel, schemaMap, identifier, namespace)}>`;
+		if (kind === "binary") return "body: Blob";
+		return `body: ${toTs(responseModel, schemaMap, identifier, namespace)}`;
+	};
+	if (responseEntries.length === 1) {
+		const [status, responseModel] = responseEntries[0];
+		const bodyField = responseBodyField(responseKind(status), responseModel);
+		if (bodyField != null) lines.push(`export type ${OperationName}Response = { status: ${status}; ${bodyField} }`);
+		else lines.push(`export type ${OperationName}Response = { status: ${status} }`);
+	} else {
+		lines.push(`export type ${OperationName}Response =`);
+		for (const [status, responseModel] of responseEntries) {
+			const bodyField = responseBodyField(responseKind(status), responseModel);
+			if (bodyField != null) lines.push(`  | { status: ${status}; ${bodyField} }`);
+			else lines.push(`  | { status: ${status} }`);
 		}
-		return deserializeFailed(model, value);
-	}
-	if (model.kind === "tagged-union") {
-		if (typeof value === "object" && !Array.isArray(value)) {
-			const tag = value[model.tag];
-			for (const [key, variant] of Object.entries(model.variants)) {
-				const tagModel = variant.properties[model.tag];
-				if (tagModel.kind === "literal" && tagModel.value === tag) {
-					const result = deserializeInner(variant, value);
-					if (result.isSuccess) return success({ [key]: result.value });
-				}
-			}
+	}
+	lines.push("");
+	const reqParam = hasParams || hasBody ? `req: ${OperationName}Request` : `req?: ${OperationName}Request`;
+	const retType = okModel && !isStreamLike ? toTs(okModel, schemaMap, identifier, namespace) : "Response";
+	const pathExpr = operation.path.replace(/\{(\w+)\}/g, (_, name) => `\${encodeURIComponent(req.${name})}`);
+	lines.push(`export async function ${functionName}(${reqParam}): Promise<${retType}> {`);
+	lines.push(`  const baseUrl = req?.baseUrl ?? ""`);
+	if (hasQuery) {
+		lines.push(`  const parts: string[] = []`);
+		for (const [n, q] of Object.entries(operation.queries)) if (q.required) lines.push(`  parts.push("${n}=" + encodeURIComponent(req.${n}))`);
+		else lines.push(`  if (req?.${n} != null) parts.push("${n}=" + encodeURIComponent(req.${n}))`);
+		lines.push(`  const qs = parts.length > 0 ? "?" + parts.join("&") : ""`);
+		lines.push(`  const url = \`\${baseUrl}${pathExpr}\${qs}\``);
+	} else lines.push(`  const url = \`\${baseUrl}${pathExpr}\``);
+	lines.push("");
+	lines.push(`  const res = await fetch(url, {`);
+	lines.push(`    method: "${operation.method}",`);
+	if (hasBody) {
+		lines.push(`    headers: { "Content-Type": "application/json", ...req.headers },`);
+		lines.push(`    body: JSON.stringify(req.body),`);
+	} else lines.push(`    headers: req?.headers,`);
+	lines.push(`  })`);
+	lines.push(`  if (!res.ok) throw new Error(\`${operation.method} ${operation.path} failed: \${res.status}\`)`);
+	if (okModel && !isStreamLike) if (okSchema) lines.push(`  return ${okSchema}.parse(await res.json())`);
+	else lines.push(`  return res.json()`);
+	else lines.push(`  return res`);
+	lines.push(`}`);
+	return lines.join("\n");
+}
+function generateClientIndex(operations, _identifier) {
+	const lines = [];
+	const groups = groupBy(operations, (operation) => operation.group);
+	for (const [group, groupOps] of Object.entries(groups)) {
+		lines.push(`// ── ${group} ──`);
+		for (const operation of groupOps) {
+			const n = camelCase(operation.id);
+			const OperationName = pascalCase(operation.id);
+			lines.push(`export { ${n}, type ${OperationName}Request, type ${OperationName}Response } from "./${n}"`);
 		}
-		return deserializeFailed(model, value);
-	}
-	if (typeof value === "object" && !Array.isArray(value) && "code" in value && "context" in value && value.code === model.code && typeof value.context === "object" && !Array.isArray(value.context)) {
-		const properties = /* @__PURE__ */ new Map();
-		for (const key in model.context) {
-			const result = deserializeInner(model.context[key], value[key]);
-			if (result.isSuccess) properties.set(key, result.value);
-			else return result;
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function groupBy(items, keyFn) {
+	const map = {};
+	for (const item of items) {
+		const key = keyFn(item);
+		if (!map[key]) map[key] = [];
+		map[key].push(item);
+	}
+	return map;
+}
+function toTs(model, schemaMap, identifier, namespace) {
+	switch (model.kind) {
+		case "int32":
+		case "float32":
+		case "float64": return "number";
+		case "boolean": return "boolean";
+		case "string":
+		case "datetime":
+		case "date":
+		case "duration": return "string";
+		case "literal": return JSON.stringify(model.value);
+		case "null": return "null";
+		case "array":
+		case "set": return `${toTs(model.base, schemaMap, identifier, namespace)}[]`;
+		case "map": return `Record<string, ${toTs(model.base, schemaMap, identifier, namespace)}>`;
+		case "enums":
+			if (schemaMap.get(model.id)?.variants) return identifier(model.id);
+			return Object.values(model.variants).map((v) => JSON.stringify(v)).join(" | ");
+		case "record": return schemaMap.get(model.id)?.fields ? identifier(model.id) : "unknown";
+		case "union":
+		case "taggedUnion":
+			if (schemaMap.get(model.id)?.unionVariants) return identifier(model.id);
+			return Object.values(model.variants).map((v) => toTs(v, schemaMap, identifier, namespace)).join(" | ");
+		default: return "unknown";
+	}
+}
+function toZod(model, schemaMap) {
+	switch (model.kind) {
+		case "int32": return "z.coerce.number().int()";
+		case "float32":
+		case "float64": return "z.coerce.number()";
+		case "boolean": return "z.coerce.boolean()";
+		case "string": return "z.string()";
+		case "datetime": return "z.string().datetime()";
+		case "date": return "z.string().date()";
+		case "duration": return "z.string()";
+		case "literal": return `z.literal(${JSON.stringify(model.value)})`;
+		case "null": return "z.null()";
+		case "array": return `${toZod(model.base, schemaMap)}.array()`;
+		case "set": return `${toZod(model.base, schemaMap)}.array()`;
+		case "map": return `z.record(z.string(), ${toZod(model.base, schemaMap)})`;
+		case "enums": return `z.enum(${JSON.stringify(Object.values(model.variants))})`;
+		case "record": return schemaMap.get(model.id)?.fields ? camelCase(model.id) + "Schema" : "z.unknown()";
+		case "union":
+			if (schemaMap.get(model.id)?.unionVariants) return camelCase(model.id) + "Schema";
+			return `z.union([${Object.values(model.variants).map((v) => toZod(v, schemaMap)).join(", ")}])`;
+		case "taggedUnion": {
+			if (schemaMap.get(model.id)?.unionVariants) return camelCase(model.id) + "Schema";
+			const items = Object.entries(model.variants).map(([key, v]) => `z.object({ ${JSON.stringify(model.variantKey)}: z.literal(${JSON.stringify(key)}), ${JSON.stringify(model.payloadKey)}: ${toZod(v, schemaMap)} })`);
+			return `z.discriminatedUnion(${JSON.stringify(model.variantKey)}, [${items.join(", ")}])`;
 		}
-		return success({
-			code: model.code,
-			context: Object.fromEntries(properties)
-		});
+		default: return "z.unknown()";
 	}
-	return deserializeFailed(model, value);
 }
-function deserializeFailed(expect, receive) {
-	return {
-		isSuccess: false,
-		code: "deserial-failed",
-		context: {
-			expect,
-			receive
+function resolveZodSchema(model, schemaMap) {
+	switch (model.kind) {
+		case "record":
+		case "union":
+		case "taggedUnion":
+		case "enums": return schemaMap.get(model.id) ? camelCase(model.id) + "Schema" : null;
+		case "array":
+		case "set": {
+			const inner = resolveZodSchema(model.base, schemaMap);
+			return inner ? `${inner}.array()` : null;
 		}
-	};
+		case "map": {
+			const inner = resolveZodSchema(model.base, schemaMap);
+			return inner ? `z.record(z.string(), ${inner})` : null;
+		}
+		default: return null;
+	}
 }
-function serialize(model, value) {
-	if (model.kind === "string" || model.kind === "int64") return `"${value.toString()}"`;
-	if (model.kind === "int32" || model.kind === "float32" || model.kind === "float64" || model.kind === "boolean") return value.toString();
-	if (model.kind === "array") return value.map((o) => serialize(model.base, o)).join(",");
-	if (model.kind === "set") return value.values().map((o) => serialize(model.base, o)).toArray().join(",");
-	if (model.kind === "map") return `{${value.entries().map(([k, v]) => `"${k}": ${serialize(model.base, v)}`)}}`;
-	if (model.kind === "literal") return model.value.toString();
-	if (model.kind === "date" || model.kind === "datetime" || model.kind === "duration") return value.toJSON();
-	if (model.kind === "optional") return value == null ? "null" : serialize(model.base, value);
-	if (model.kind === "error") {
-		const properties = [];
-		for (const key in model.context) properties.push(`"${key}": ${serialize(model.context[key], value[key])}`);
-		return `{"code":"${model.code}",context:{${properties}}}`;
-	}
-	if (model.kind === "record") {
-		const properties = [];
-		for (const key in model.properties) properties.push(`"${key}": ${serialize(model.properties[key], value[key])}`);
-		return `{${properties}}`;
-	}
-	if (model.kind === "union") {
-		const variantKeys = Object.keys(model.variants);
-		for (const key of variantKeys) if (key in value) return `{"${key}":${serialize(model.variants[key], value[key])}}`;
-	}
-	if (model.kind === "tagged-union") return JSON.stringify(value);
-	return String(value);
+function collectSchemaRefs(model, schemaMap) {
+	switch (model.kind) {
+		case "record":
+		case "union":
+		case "taggedUnion":
+		case "enums": return schemaMap.get(model.id) ? [camelCase(model.id) + "Schema"] : [];
+		case "array":
+		case "set": return collectSchemaRefs(model.base, schemaMap);
+		case "map": return collectSchemaRefs(model.base, schemaMap);
+		default: return [];
+	}
 }
 //#endregion
-export { array, binary, boolean, collectModelDeep, collectModelFromRoutes, date, datetime, deserialize, deserializeInner, duration, enums, error, float32, float64, form, formatJava, formatRust, generateJavaClass, generateJavaCodes, generateJsonSchema, generateOpenapi, generateRustCode, generateRustCodes, int32, int64, json, jsonStream, literal, map, optional, plainText, plainTextStream, record, route, serialize, set, string, taggedUnion, union };
+export { apikey, array, binary, boolean, collectNamedModels, collectOperations, collectSchemaMap, createJsonSchemaRegistry, createOpenapiSchemaRegistry, date, datetime, deployOpenIdConnect, duration, enums, float32, float64, generateHonoServer, generateJsonSchema, generateOpenapi, generateTsClient, int32, json, jsonStream, literal, map, mergeJsonSchemas, nullLike, openIdConnect, record, resolveNamedRoot, route, set, sseStream, string, taggedUnion, union };
 
 //# sourceMappingURL=index.mjs.map