@kizunajs/fetch 2.0.0-beta.12 → 2.0.0-beta.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kizunajs/fetch",
-  "version": "2.0.0-beta.12",
-  "description": "Typed fetch client for Kizuna.js APIs",
+  "version": "2.0.0-beta.14",
+  "description": "Fetch client generation for Kizuna.js APIs",
   "keywords": [
     "kizunajs",
     "typescript",
@@ -42,22 +42,11 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
-    },
-    "./server": {
-      "import": {
-        "types": "./dist/server.d.mts",
-        "default": "./dist/server.mjs"
-      },
-      "require": {
-        "types": "./dist/server.d.cts",
-        "default": "./dist/server.cjs"
-      }
     }
   },
   "kizuna": {
     "entries": {
-      ".": "client",
-      "./server": "server"
+      ".": "server"
     }
   },
   "files": [
@@ -68,7 +57,7 @@
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "kizunajs": "2.0.0-beta.12"
+    "kizunajs": "2.0.0-beta.14"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -76,11 +65,11 @@
     "tsdown": "^0.21.0",
     "typescript": "^6.0.3",
     "zod": "^4.0.0",
-    "kizunajs": "2.0.0-beta.12",
-    "@kizunajs/express": "2.0.0-beta.12"
+    "kizunajs": "2.0.0-beta.14",
+    "@kizunajs/express": "2.0.0-beta.14"
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/server.ts --format esm,cjs --dts --clean --external kizunajs --external zod",
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean --external kizunajs --external zod",
     "typecheck": "tsc --noEmit"
   }
 }

package/dist/server.cjs

@@ -1,479 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let kizunajs_schemas = require("kizunajs/schemas");
-let kizunajs_generator = require("kizunajs/generator");
-let zod = require("zod");
-//#region src/zod-to-typescript.ts
-/**
-* Collects the named types a walk produces, so a model shared by many routes is
-* declared once.
-*/
-var TypeCollector = class {
-	named = /* @__PURE__ */ new Map();
-	claimed = /* @__PURE__ */ new Set();
-	/**
-	* Claims a name before its body is walked, so a model that refers to itself
-	* resolves to its own name instead of recursing. Answers whether the caller
-	* is the one that has to emit it.
-	*/
-	claim(name) {
-		if (this.claimed.has(name)) return false;
-		this.claimed.add(name);
-		return true;
-	}
-	add(type) {
-		this.named.set(type.name, type);
-	}
-	all() {
-		return [...this.named.values()].sort((left, right) => left.name.localeCompare(right.name));
-	}
-};
-const quote = (value) => JSON.stringify(value);
-/**
-* A literal as the type the JSON carries, so `z.literal(true)` is `true`.
-*/
-const literalType = (value) => {
-	if (typeof value === "string") return quote(value);
-	if (typeof value === "bigint") return `${value}n`;
-	if (value === void 0) return "undefined";
-	return String(value);
-};
-const indent$1 = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
-/**
-* A property name, quoted only when it is not a plain identifier.
-*/
-const propertyKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : quote(key);
-/**
-* A doc comment over the lines it is given, or nothing when there are none.
-* Always multi-line, the way the rest of this repository writes them.
-*/
-const docComment = (lines) => {
-	const body = lines.flatMap((line) => line.split("\n"));
-	if (body.length === 0) return "";
-	return `/**\n${body.map((line) => ` * ${line}`.trimEnd()).join("\n")}\n */\n`;
-};
-/**
-* Renders a declared example as the TypeScript literal a caller would write.
-*/
-const exampleLiteral = (value) => {
-	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-	if (value === void 0) return "undefined";
-	return JSON.stringify(value) ?? "undefined";
-};
-const STRING_SAMPLES = {
-	email: "ada@example.com",
-	url: "https://example.com",
-	uuid: "3f1c2d9e-5b6a-4c7d-8e9f-0a1b2c3d4e5f",
-	datetime: "2026-01-01T00:00:00Z",
-	date: "2026-01-01",
-	time: "00:00:00"
-};
-const stringSample = (schema, key) => {
-	const def = (0, kizunajs_generator.readDef)(schema);
-	const formats = [def.format, ...(def.checks ?? []).map((check) => check.format ?? check.def?.format)];
-	for (const format of formats) if (format !== void 0 && format in STRING_SAMPLES) return exampleLiteral(STRING_SAMPLES[format]);
-	if (key !== void 0 && /id$/i.test(key)) return exampleLiteral("1");
-	return exampleLiteral("string");
-};
-/**
-* A value a caller could pass for a schema, used in the `@example` on each
-* client method. A schema that declares an example is taken at its word;
-* anything else gets a value of the right shape.
-*/
-const sampleValue = (schema, depth = 0, key) => {
-	const [declared] = (0, kizunajs_generator.readMetaExamples)(schema);
-	if (declared !== void 0) return exampleLiteral(declared);
-	if ((0, kizunajs_generator.isFileSchema)(schema)) return "new File([], 'upload.txt')";
-	if ((0, kizunajs_generator.isBinarySchema)(schema)) return "new Uint8Array()";
-	const def = (0, kizunajs_generator.readDef)(schema);
-	if (def.type === "default" && def.defaultValue !== void 0) return exampleLiteral(def.defaultValue);
-	if (def.type === "pipe") {
-		const side = def.out ?? def.in;
-		return side ? sampleValue(side, depth, key) : "undefined";
-	}
-	if (def.innerType && def.type !== "object") return sampleValue(def.innerType, depth, key);
-	switch (def.type) {
-		case "number":
-		case "int": return "1";
-		case "bigint": return "1n";
-		case "boolean": return "true";
-		case "date": return exampleLiteral("2026-01-01");
-		case "null": return "null";
-		case "literal": return def.values?.length ? exampleLiteral(def.values[0]) : "undefined";
-		case "enum": {
-			const [first] = Object.values(def.entries ?? {});
-			return first === void 0 ? "undefined" : exampleLiteral(first);
-		}
-		case "array":
-			if (!def.element || depth >= SAMPLE_DEPTH) return "[]";
-			return `[\n${indent$1(`${sampleValue(def.element, depth + 1, key)},`)}\n]`;
-		case "object": return sampleObject(schema, depth);
-		case "record": return "{}";
-		case "union": {
-			const options = (0, kizunajs_generator.readDiscriminatedUnion)(schema)?.options ?? def.options ?? [];
-			return options[0] ? sampleValue(options[0], depth, key) : "undefined";
-		}
-		case "string": return stringSample(schema, key);
-		default: return "undefined";
-	}
-};
-const SAMPLE_DEPTH = 2;
-/**
-* The required fields of an object schema, written as the literal a caller
-* would pass. Optional fields are left out, since an example shows the least
-* the route needs.
-*/
-const sampleObject = (schema, depth = 0) => {
-	const shape = (0, kizunajs_generator.readObjectShape)(schema);
-	if (!shape) return "{}";
-	const required = Object.entries(shape).filter(([, field]) => !(0, kizunajs_generator.unwrapOptionalWrappers)(field).optional);
-	if (required.length === 0 || depth >= SAMPLE_DEPTH) return "{}";
-	return `{\n${indent$1(required.map(([key, field]) => `${propertyKey(key)}: ${sampleValue((0, kizunajs_generator.unwrapOptionalWrappers)(field).inner, depth + 1, key)},`).join("\n"))}\n}`;
-};
-/**
-* What an editor shows above a field: its description, whether it is on its way
-* out, and the values the schema declares as examples.
-*/
-const fieldDoc = (field) => {
-	const lines = [];
-	const description = (0, kizunajs_generator.readMetaDescription)(field);
-	if (description !== void 0) lines.push(description);
-	const deprecation = (0, kizunajs_generator.readDeprecation)(field);
-	if (deprecation !== void 0) {
-		if (lines.length > 0) lines.push("");
-		lines.push(`@deprecated ${deprecation.message ?? ""}`.trimEnd());
-	}
-	for (const example of (0, kizunajs_generator.readMetaExamples)(field)) {
-		if (lines.length > 0) lines.push("");
-		lines.push("@example", exampleLiteral(example));
-	}
-	return lines;
-};
-const objectBody = (schema, collector, hint) => {
-	const shape = (0, kizunajs_generator.readObjectShape)(schema);
-	if (!shape) return "Record<string, unknown>";
-	const entries = Object.entries(shape);
-	if (entries.length === 0) return "Record<string, never>";
-	return `{\n${indent$1(entries.map(([key, field]) => {
-		const doc = docComment(fieldDoc(field));
-		const mark = (0, kizunajs_generator.unwrapOptionalWrappers)(field).optional ? "?" : "";
-		return `${doc}${propertyKey(key)}${mark}: ${typeOf(field, collector, `${hint}${(0, kizunajs_generator.toPascalCase)(key)}`)};`;
-	}).join("\n"))}\n}`;
-};
-/**
-* The TypeScript type a schema describes. Named models are collected and
-* referenced; anonymous shapes are inlined.
-*/
-const typeOf = (schema, collector, hint) => {
-	if ((0, kizunajs_generator.isFileSchema)(schema)) return "File | Blob";
-	if ((0, kizunajs_generator.isBinarySchema)(schema)) return "Uint8Array";
-	const def = (0, kizunajs_generator.readDef)(schema);
-	if (def.type === "nullable" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
-	if (def.type === "nullish" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
-	if (def.innerType && def.type !== "object") return typeOf(def.innerType, collector, hint);
-	if (def.type === "pipe") {
-		const side = def.out ?? def.in;
-		return side ? typeOf(side, collector, hint) : "unknown";
-	}
-	const modelName = (0, kizunajs_generator.readMetaId)(schema);
-	if (modelName !== void 0) {
-		if (collector.claim(modelName)) collector.add({
-			name: modelName,
-			description: (0, kizunajs_generator.readMetaDescription)(schema),
-			body: structuralType(schema, collector, modelName)
-		});
-		return modelName;
-	}
-	return structuralType(schema, collector, hint);
-};
-/**
-* The type a schema describes by its shape, its name already spent by the caller.
-*/
-const structuralType = (schema, collector, hint) => {
-	const def = (0, kizunajs_generator.readDef)(schema);
-	switch (def.type) {
-		case "string": return "string";
-		case "number":
-		case "int": return "number";
-		case "bigint": return "string";
-		case "boolean": return "boolean";
-		case "date": return "string";
-		case "null": return "null";
-		case "any":
-		case "unknown": return "unknown";
-		case "never": return "never";
-		case "void":
-		case "undefined": return "undefined";
-		case "literal": {
-			const values = def.values ?? [];
-			return values.length > 0 ? values.map(literalType).join(" | ") : "never";
-		}
-		case "enum": {
-			const values = Object.values(def.entries ?? {});
-			return values.length > 0 ? values.map(literalType).join(" | ") : "never";
-		}
-		case "array": return def.element ? `Array<${typeOf(def.element, collector, `${hint}Item`)}>` : "unknown[]";
-		case "object": return objectBody(schema, collector, hint);
-		case "record": return `Record<string, ${def.valueType ? typeOf(def.valueType, collector, `${hint}Value`) : "unknown"}>`;
-		case "union": {
-			const options = (0, kizunajs_generator.readDiscriminatedUnion)(schema)?.options ?? def.options ?? [];
-			if (options.length === 0) return "unknown";
-			return options.map((option, index) => typeOf(option, collector, `${hint}${index}`)).join(" | ");
-		}
-		default: return "unknown";
-	}
-};
-//#endregion
-//#region src/generator.ts
-const indent = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
-const pathParamNames = (path) => [...path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1] ?? "");
-/**
-* One server-sent event, typed from what the response declares. A record of
-* event name to schema becomes a union discriminated on `event`; a single
-* schema is the only shape a message takes.
-*/
-const eventUnion = (stream, collector, namespace) => {
-	const frame = "id?: string; retry?: number";
-	if (stream && typeof stream === "object" && !("_zod" in stream) && !("_def" in stream)) {
-		const arms = Object.entries(stream).map(([event, schema]) => `{ event: '${event}'; data: ${typeOf(schema, collector, `${namespace}${(0, kizunajs_generator.toPascalCase)(event)}`)}; ${frame} }`);
-		return arms.length > 0 ? arms.join(" | ") : `{ event?: string; data: string; ${frame} }`;
-	}
-	return `{ event?: string; data: ${typeOf(stream, collector, `${namespace}Message`)}; ${frame} }`;
-};
-const streamBody = (mode, stream, collector, namespace) => {
-	if (mode === "binary") return "AsyncIterable<Uint8Array>";
-	if (mode === "text") return "AsyncIterable<string>";
-	return `AsyncIterable<${eventUnion(stream, collector, namespace)}>`;
-};
-/**
-* The call a route's `@example` shows: the arguments it cannot be called
-* without, filled with values of the shape each schema declares.
-*/
-const exampleCall = (routeKey, route) => {
-	const entries = [];
-	const params = pathParamNames(route.path);
-	if (params.length > 0) {
-		const shape = route.pathParams ? (0, kizunajs_generator.readObjectShape)(route.pathParams) : void 0;
-		const fields = params.map((name) => {
-			const declared = shape?.[name];
-			return `${name}: ${declared ? sampleValue(declared, 0, name) : "'1'"},`;
-		});
-		entries.push(`params: {\n${indent(fields.join("\n"))}\n},`);
-	}
-	if (route.query && requiresArgument(route.query)) entries.push(`query: ${sampleObject(route.query)},`);
-	if (route.body && !(0, kizunajs_generator.isVoidSchema)(route.body) && requiresArgument(route.body)) entries.push(`body: ${sampleValue(route.body)},`);
-	return `const result = await client.${routeKey}(${entries.length > 0 ? `{\n${indent(entries.join("\n"))}\n}` : ""});`;
-};
-/**
-* Whether a schema has anything a caller has to pass, so a route whose query is
-* every-field-optional keeps its example to the call itself.
-*/
-const requiresArgument = (schema) => {
-	const shape = (0, kizunajs_generator.readObjectShape)(schema);
-	if (!shape) return true;
-	return Object.values(shape).some((field) => !(0, kizunajs_generator.unwrapOptionalWrappers)(field).optional);
-};
-/**
-* What an editor shows above a client method: what the route is for, whether it
-* is on its way out, and how it is called.
-*/
-const routeDoc = (routeKey, route) => {
-	const lines = [];
-	if (route.summary) lines.push(route.summary);
-	if (route.description) {
-		if (lines.length > 0) lines.push("");
-		lines.push(route.description);
-	}
-	if (route.deprecated !== void 0 && route.deprecated !== false) {
-		const message = typeof route.deprecated === "string" ? route.deprecated : typeof route.deprecated === "object" ? route.deprecated.message : void 0;
-		if (lines.length > 0) lines.push("");
-		lines.push(`@deprecated ${message ?? ""}`.trimEnd());
-	}
-	if (lines.length > 0) lines.push("");
-	lines.push("@example", exampleCall(routeKey, route));
-	return docComment(lines);
-};
-const emitRoute = (routeKey, key, route, collector, namespaceName) => {
-	const namespace = routeKey.split(".").map(kizunajs_generator.toPascalCase).join("");
-	const members = [];
-	const args = [];
-	const params = pathParamNames(route.path);
-	if (params.length > 0) {
-		const body = route.pathParams ? typeOf(route.pathParams, collector, `${namespace}Params`) : `{\n${indent(params.map((name) => `${name}: string;`).join("\n"))}\n}`;
-		members.push(`export type Params = ${body};`);
-		args.push(`params: ${namespaceName}.${namespace}.Params`);
-	}
-	if (route.query) {
-		members.push(`export type Query = ${typeOf(route.query, collector, `${namespace}Query`)};`);
-		args.push(`query?: ${namespaceName}.${namespace}.Query`);
-	}
-	if (route.body && !(0, kizunajs_generator.isVoidSchema)(route.body)) {
-		members.push(`export type Body = ${typeOf(route.body, collector, `${namespace}Body`)};`);
-		args.push(`body: ${namespaceName}.${namespace}.Body`);
-	}
-	if (route.headers) {
-		members.push(`export type Headers = ${typeOf(route.headers, collector, `${namespace}Headers`)};`);
-		args.push(`headers?: ${namespaceName}.${namespace}.Headers`);
-	} else args.push("headers?: Record<string, string>");
-	args.push("fetchOptions?: RequestInit");
-	const validates = route.body !== void 0 || route.query !== void 0;
-	const declaredBadRequest = Object.keys(route.responses).includes("400");
-	const validationBody = validates ? typeOf(kizunajs_schemas.ValidationErrorSchema, collector, "ValidationError") : void 0;
-	const results = Object.entries(route.responses).map(([status, response]) => {
-		const headers = (0, kizunajs_generator.resolveResponseHeaders)(response);
-		const headerType = headers ? typeOf(headers, collector, `${namespace}${status}Headers`) : "Record<string, string>";
-		if ((0, kizunajs_generator.isStreamResponse)(response)) return `{ status: ${status}; body: ${streamBody((0, kizunajs_generator.streamContentType)(response).includes("event-stream") ? "events" : (0, kizunajs_generator.streamContentType)(response).startsWith("text/") ? "text" : "binary", response.stream, collector, `${namespace}${status}`)}; headers: ${headerType} }`;
-		const schema = (0, kizunajs_generator.resolveResponseBody)(response);
-		const body = schema ? typeOf(schema, collector, `${namespace}${status}`) : "undefined";
-		return `{ status: ${status}; body: ${status === "400" && validationBody ? `${body} | ${validationBody}` : body}; headers: ${headerType} }`;
-	});
-	if (validationBody && !declaredBadRequest) results.push(`{ status: 400; body: ${validationBody}; headers: Record<string, string> }`);
-	members.push(`export type Result =\n${indent(results.map((result) => `| ${result}`).join("\n"))};`);
-	const argsType = `{\n${indent(args.map((arg) => `${arg};`).join("\n"))}\n}`;
-	const tableEntries = [`method: '${route.method}'`, `path: '${route.path}'`];
-	if (route.contentType) tableEntries.push(`contentType: '${route.contentType}'`);
-	const responses = Object.entries(route.responses).map(([status, response]) => (0, kizunajs_generator.isStreamResponse)(response) ? `${status}: { stream: { contentType: '${(0, kizunajs_generator.streamContentType)(response)}' } }` : `${status}: {}`);
-	tableEntries.push(`responses: {\n${indent(responses.map((entry) => `${entry},`).join("\n"))}\n}`);
-	const streams = Object.values(route.responses).some((response) => (0, kizunajs_generator.isStreamResponse)(response));
-	return {
-		namespace,
-		signature: `${routeDoc(routeKey, route)}${key}: ClientMethod<'${route.method}', ${streams}, ${argsType}, ${namespaceName}.${namespace}.Result>;`,
-		declaration: `export namespace ${namespace} {\n${indent(members.join("\n\n"))}\n}`,
-		table: `${key}: {\n${indent(tableEntries.map((entry) => `${entry},`).join("\n"))}\n},`
-	};
-};
-const isRoute = (value) => !!value && typeof value === "object" && typeof value.method === "string";
-const emitTree = (routes, prefix, collector, namespaceName) => {
-	const signatures = [];
-	const tables = [];
-	const declarations = [];
-	for (const key of Object.keys(routes)) {
-		const node = routes[key];
-		const routeKey = prefix ? `${prefix}.${key}` : key;
-		if (isRoute(node)) {
-			const emitted = emitRoute(routeKey, key, node, collector, namespaceName);
-			signatures.push(emitted.signature);
-			tables.push(emitted.table);
-			declarations.push(emitted.declaration);
-			continue;
-		}
-		if (node && typeof node === "object") {
-			const group = emitTree(node, routeKey, collector, namespaceName);
-			signatures.push(`${key}: {\n${indent(group.signatures)}\n};`);
-			tables.push(`${key}: {\n${indent(group.table)}\n},`);
-			declarations.push(...group.declarations);
-		}
-	}
-	return {
-		signatures: signatures.join("\n"),
-		table: tables.join("\n"),
-		declarations
-	};
-};
-/**
-* Renders a TypeScript client from an api: its named types, the route table
-* the runtime reads, and a `createClient` typed against both.
-*/
-/**
-* The headers a request context declares, as one interface the caller fills
-* once. Absent when the API declares no request context that reads headers.
-*/
-const emitRequestContext = (contract, collector) => {
-	const declarations = Object.values(contract.requestContext ?? {});
-	const fields = [];
-	for (const declaration of declarations) {
-		const headers = declaration.headers;
-		if (!headers) continue;
-		const inner = typeOf(headers, collector, "RequestContext").trim().replace(/^\{/, "").replace(/\}$/, "").split("\n").map((line) => line.trim()).filter((line) => line !== "").join("\n");
-		if (inner !== "") fields.push(inner);
-	}
-	return fields.length > 0 ? `export interface RequestContext {\n${indent(fields.join("\n"))}\n}` : void 0;
-};
-const generateFetchClient = (contract, options = {}) => {
-	const { namespace: namespaceName = "API", runtimeModule = "@kizunajs/fetch", regenerateCommand = "kizuna generate", source } = options;
-	const collector = new TypeCollector();
-	const tree = emitTree((0, kizunajs_generator.listedRoutes)(contract), "", collector, namespaceName);
-	const api = [...collector.all().map((model) => {
-		return `${model.description ? `/**\n * ${model.description}\n */\n` : ""}export type ${model.name} = ${model.body};`;
-	}), ...tree.declarations].join("\n\n");
-	const requestContext = emitRequestContext(contract, collector);
-	return `/* eslint-disable */
-/**
-${[
-		" * Generated by @kizunajs/fetch. Do not edit.",
-		" *",
-		...source === void 0 ? [] : [` * Source: ${source}`],
-		` * Regenerate: ${regenerateCommand}`
-	].join("\n")}
- */
-import { createGeneratedClient, type ClientConfig, type ClientMethod, type GeneratedRoutes } from '${runtimeModule}';
-
-export namespace ${namespaceName} {
-${indent(api)}
-}
-
-export interface Client {
-${indent(tree.signatures)}
-}
-
-const routes: GeneratedRoutes = {
-${indent(tree.table)}
-};
-
-${requestContext === void 0 ? `/**
- * A client for this API. Pass the base URL and anything else the runtime takes.
- */
-export const createClient = (config: ClientConfig): Client => createGeneratedClient(routes, config) as unknown as Client;` : `${requestContext}
-
-/**
- * A client for this API. Pass the base URL, the request context headers this
- * API declares, and anything else the runtime takes.
- */
-export const createClient = (config: ClientConfig & { requestContext?: RequestContext }): Client =>
-    createGeneratedClient(routes, config) as unknown as Client;`}
-`;
-};
-//#endregion
-//#region src/client-target.ts
-const FetchClientOptionsSchema = zod.z.object({
-	/**
-	* Name of the generated namespace holding every model and every route's
-	* `Params`, `Query`, `Body`, `Headers` and `Result`.
-	*
-	* @default 'API'
-	*/
-	namespace: zod.z.string().optional(),
-	/**
-	* Module the generated file imports its runtime from.
-	*
-	* @default '@kizunajs/fetch'
-	*/
-	runtimeModule: zod.z.string().optional(),
-	/**
-	* Command the file's header tells a reader to run.
-	*
-	* @default 'kizuna generate'
-	*/
-	regenerateCommand: zod.z.string().optional(),
-	/**
-	* Path to the api this was generated from, relative to the generated
-	* file. Named in the header so tooling can tell when the client has fallen
-	* behind, and so a reader knows where the API is declared.
-	*/
-	source: zod.z.string().optional()
-});
-/**
-* A TypeScript client for `kizuna.config.ts`.
-*
-* @example
-* fetchClient({
-*     output: './packages/api-client/src/generated.ts',
-* });
-*/
-const fetchClient = (0, kizunajs_generator.defineClient)({
-	target: "fetch",
-	options: FetchClientOptionsSchema,
-	generate: ({ options, api }) => ({ finalize: () => generateFetchClient(api, options) })
-});
-//#endregion
-exports.fetchClient = fetchClient;
-exports.generateFetchClient = generateFetchClient;

package/dist/server.d.cts

@@ -1,65 +0,0 @@
-import { z } from "zod";
-import * as _$kizunajs from "kizunajs";
-import { ApiDefinition } from "kizunajs";
-import { GeneratedFileOptions } from "kizunajs/generator";
-
-//#region src/generator.d.ts
-/**
- * What a generated client is called and where its runtime comes from.
- */
-interface FetchClientOptions {
-  /**
-   * Name of the generated namespace holding every model and every route's
-   * `Params`, `Query`, `Body`, `Headers` and `Result`.
-   *
-   * @default 'API'
-   */
-  namespace?: string;
-  /**
-   * Module the generated file imports its runtime from.
-   *
-   * @default '@kizunajs/fetch'
-   */
-  runtimeModule?: string;
-  /**
-   * Command the file's header tells a reader to run.
-   *
-   * @default 'kizuna generate'
-   */
-  regenerateCommand?: string;
-  /**
-   * Path to the api this was generated from, relative to the generated
-   * file. Named in the header so tooling can tell when the client has fallen
-   * behind, and so a reader knows where the API is declared.
-   */
-  source?: string;
-}
-declare const generateFetchClient: (contract: ApiDefinition, options?: FetchClientOptions) => string;
-//#endregion
-//#region src/client-target.d.ts
-declare const FetchClientOptionsSchema: z.ZodObject<{
-  namespace: z.ZodOptional<z.ZodString>;
-  runtimeModule: z.ZodOptional<z.ZodString>;
-  regenerateCommand: z.ZodOptional<z.ZodString>;
-  source: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Where a generated TypeScript client is written.
- */
-type FetchClientTargetOptions = z.input<typeof FetchClientOptionsSchema> & GeneratedFileOptions;
-/**
- * A TypeScript client for `kizuna.config.ts`.
- *
- * @example
- * fetchClient({
- *     output: './packages/api-client/src/generated.ts',
- * });
- */
-declare const fetchClient: (options: {
-  namespace?: string | undefined;
-  runtimeModule?: string | undefined;
-  regenerateCommand?: string | undefined;
-  source?: string | undefined;
-} & GeneratedFileOptions) => _$kizunajs.GeneratedFile;
-//#endregion
-export { type FetchClientOptions, type FetchClientTargetOptions, fetchClient, generateFetchClient };

package/dist/server.d.mts

@@ -1,65 +0,0 @@
-import * as _$kizunajs from "kizunajs";
-import { ApiDefinition } from "kizunajs";
-import { GeneratedFileOptions } from "kizunajs/generator";
-import { z } from "zod";
-
-//#region src/generator.d.ts
-/**
- * What a generated client is called and where its runtime comes from.
- */
-interface FetchClientOptions {
-  /**
-   * Name of the generated namespace holding every model and every route's
-   * `Params`, `Query`, `Body`, `Headers` and `Result`.
-   *
-   * @default 'API'
-   */
-  namespace?: string;
-  /**
-   * Module the generated file imports its runtime from.
-   *
-   * @default '@kizunajs/fetch'
-   */
-  runtimeModule?: string;
-  /**
-   * Command the file's header tells a reader to run.
-   *
-   * @default 'kizuna generate'
-   */
-  regenerateCommand?: string;
-  /**
-   * Path to the api this was generated from, relative to the generated
-   * file. Named in the header so tooling can tell when the client has fallen
-   * behind, and so a reader knows where the API is declared.
-   */
-  source?: string;
-}
-declare const generateFetchClient: (contract: ApiDefinition, options?: FetchClientOptions) => string;
-//#endregion
-//#region src/client-target.d.ts
-declare const FetchClientOptionsSchema: z.ZodObject<{
-  namespace: z.ZodOptional<z.ZodString>;
-  runtimeModule: z.ZodOptional<z.ZodString>;
-  regenerateCommand: z.ZodOptional<z.ZodString>;
-  source: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * Where a generated TypeScript client is written.
- */
-type FetchClientTargetOptions = z.input<typeof FetchClientOptionsSchema> & GeneratedFileOptions;
-/**
- * A TypeScript client for `kizuna.config.ts`.
- *
- * @example
- * fetchClient({
- *     output: './packages/api-client/src/generated.ts',
- * });
- */
-declare const fetchClient: (options: {
-  namespace?: string | undefined;
-  runtimeModule?: string | undefined;
-  regenerateCommand?: string | undefined;
-  source?: string | undefined;
-} & GeneratedFileOptions) => _$kizunajs.GeneratedFile;
-//#endregion
-export { type FetchClientOptions, type FetchClientTargetOptions, fetchClient, generateFetchClient };