@kizunajs/fetch 2.0.0-beta.0

package/LICENSE.MD

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Sondre Ørland
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @kizunajs/fetch
+
+`@kizunajs/fetch` is the typed client for your routes, a wrapper around the native `fetch` API. It runs anywhere `fetch` does, React Native included.
+
+## Installation
+
+```sh
+pnpm add @kizunajs/fetch
+```
+
+## Usage
+
+Add `fetchClient` to your config and run `kizuna generate`:
+
+```ts
+import { fetchClient } from '@kizunajs/fetch/server';
+
+export default defineConfig({
+    adapter: expressAdapter(),
+    routes: {
+        users,
+    },
+    clients: [
+        fetchClient({
+            output: './src/lib/api-client.generated.ts',
+        }),
+    ],
+});
+```
+
+The generated file exports `createClient`:
+
+```ts
+import { createClient } from './api-client.generated';
+
+const apiClient = createClient({
+    baseUrl: 'http://localhost:3000',
+});
+
+const result = await apiClient.users.getUser({
+    params: {
+        id: '1',
+    },
+});
+```
+
+## Documentation
+
+[Fetch client](https://kizunajs.com/docs/clients/fetch)

package/dist/index.cjs

@@ -0,0 +1,278 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let kizunajs = require("kizunajs");
+//#region src/sse.ts
+const parseData = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+const findLineEnd = (buffer, final) => {
+	for (let index = 0; index < buffer.length; index += 1) {
+		const character = buffer[index];
+		if (character === "\n") return {
+			index,
+			length: 1
+		};
+		if (character === "\r") {
+			if (index + 1 < buffer.length) return {
+				index,
+				length: buffer[index + 1] === "\n" ? 2 : 1
+			};
+			if (final) return {
+				index,
+				length: 1
+			};
+			return;
+		}
+	}
+};
+/**
+* Parses `text/event-stream` per the WHATWG HTML specification.
+*/
+async function* parseServerSentEvents(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let first = true;
+	let dataLines = [];
+	let eventType = "";
+	let lastEventId = "";
+	let retry;
+	const dispatch = () => {
+		if (dataLines.length === 0) {
+			eventType = "";
+			return;
+		}
+		const message = { data: parseData(dataLines.join("\n")) };
+		if (eventType !== "") message.event = eventType;
+		if (lastEventId !== "") message.id = lastEventId;
+		if (retry !== void 0) message.retry = retry;
+		dataLines = [];
+		eventType = "";
+		retry = void 0;
+		return message;
+	};
+	const processLine = (line) => {
+		if (line === "") return dispatch();
+		if (line.startsWith(":")) return void 0;
+		const separator = line.indexOf(":");
+		const field = separator === -1 ? line : line.slice(0, separator);
+		let value = separator === -1 ? "" : line.slice(separator + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		switch (field) {
+			case "event":
+				eventType = value;
+				break;
+			case "data":
+				dataLines.push(value);
+				break;
+			case "id":
+				if (!value.includes("\0")) lastEventId = value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(value)) retry = Number(value);
+				break;
+		}
+	};
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			let chunk = done ? decoder.decode() : decoder.decode(value, { stream: true });
+			if (first && chunk.length > 0) {
+				if (chunk.charCodeAt(0) === 65279) chunk = chunk.slice(1);
+				first = false;
+			}
+			buffer += chunk;
+			for (;;) {
+				const lineEnd = findLineEnd(buffer, done);
+				if (lineEnd === void 0) break;
+				const line = buffer.slice(0, lineEnd.index);
+				buffer = buffer.slice(lineEnd.index + lineEnd.length);
+				const message = processLine(line);
+				if (message !== void 0) yield message;
+			}
+			if (done) return;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+async function* readTextChunks(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) {
+				const tail = decoder.decode();
+				if (tail.length > 0) yield tail;
+				return;
+			}
+			const text = decoder.decode(value, { stream: true });
+			if (text.length > 0) yield text;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+async function* readByteChunks(body) {
+	const reader = body.getReader();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			yield value;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+//#endregion
+//#region src/client.ts
+const buildFormData = (body) => {
+	const formData = new FormData();
+	for (const [key, entry] of Object.entries(body)) {
+		const values = Array.isArray(entry) ? entry : [entry];
+		for (const value of values) if (value instanceof File || value instanceof Blob) formData.append(key, value);
+		else if (value !== void 0 && value !== null) formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+	}
+	return formData;
+};
+/**
+* Serializes a query or path value for the URL. Dates use ISO 8601; everything
+* else uses `String`.
+*/
+const serializeValue = (value) => value instanceof Date ? value.toISOString() : String(value);
+const buildQueryString = (query) => {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) for (const item of value) params.append(key, serializeValue(item));
+		else params.append(key, serializeValue(value));
+	}
+	const result = params.toString();
+	return result.length > 0 ? `?${result}` : "";
+};
+const CLIENT_ROUTE = Symbol.for("kizuna.client-route");
+/**
+* The route a client method answers, or `undefined` for anything that is not
+* one.
+*/
+const routeOf = (value) => typeof value === "function" ? value[CLIENT_ROUTE] : void 0;
+const buildRouteFn = (route, config) => {
+	const call = async (args = {}) => {
+		const url = config.baseUrl + (0, kizunajs.buildPath)(route.path, args.params) + (args.query ? buildQueryString(args.query) : "");
+		const headers = {
+			...config.baseHeaders ?? {},
+			...args.headers ?? {}
+		};
+		let body;
+		if (args.body !== void 0) {
+			const hasContentTypeHeader = "Content-Type" in headers || "content-type" in headers;
+			switch (route.contentType) {
+				case "multipart/form-data":
+					body = args.body instanceof FormData ? args.body : buildFormData(args.body);
+					break;
+				case "application/x-www-form-urlencoded":
+					if (!hasContentTypeHeader) headers["Content-Type"] = "application/x-www-form-urlencoded";
+					body = new URLSearchParams(args.body);
+					break;
+				default:
+					if (!hasContentTypeHeader) headers["Content-Type"] = "application/json";
+					body = JSON.stringify(args.body);
+			}
+		}
+		const requestHeaders = new Headers(headers);
+		if (config.onRequest) await config.onRequest({
+			url,
+			method: route.method,
+			headers: requestHeaders,
+			route
+		});
+		const res = await (config.fetch ?? fetch)(url, {
+			method: route.method,
+			headers: requestHeaders,
+			body,
+			credentials: config.credentials,
+			...args.fetchOptions
+		});
+		const responseHeaders = {};
+		res.headers.forEach((value, key) => {
+			responseHeaders[key] = value;
+		});
+		const responseSpec = route.responses[res.status];
+		if ((0, kizunajs.isStreamResponse)(responseSpec) && res.body !== null) return {
+			status: res.status,
+			body: readStream(res.body, responseSpec),
+			headers: responseHeaders
+		};
+		const text = await res.text();
+		let parsed;
+		try {
+			parsed = text.length > 0 ? JSON.parse(text) : void 0;
+		} catch {
+			parsed = text;
+		}
+		return {
+			status: res.status,
+			body: parsed,
+			headers: responseHeaders
+		};
+	};
+	call[CLIENT_ROUTE] = route;
+	return call;
+};
+const readStream = (body, definition) => {
+	switch ((0, kizunajs.streamMode)(definition)) {
+		case "events": return parseServerSentEvents(body);
+		case "text": return readTextChunks(body);
+		case "binary": return readByteChunks(body);
+	}
+};
+const buildClientTree = (router, config) => {
+	const result = {};
+	for (const key of Object.keys(router)) {
+		const node = router[key];
+		if ((0, kizunajs.isRouteDefinition)(node)) result[key] = buildRouteFn(node, config);
+		else if (node && typeof node === "object") result[key] = buildClientTree(node, config);
+	}
+	return result;
+};
+/**
+* Folds the request context headers into `baseHeaders`, so every request
+* carries them. An explicit `baseHeaders` entry wins.
+*/
+const withContextHeaders = (config) => {
+	const contextHeaders = config.requestContext;
+	if (!contextHeaders) return config;
+	return {
+		...config,
+		baseHeaders: {
+			...Object.fromEntries(Object.entries(contextHeaders).filter(([, value]) => value !== void 0)),
+			...config.baseHeaders ?? {}
+		}
+	};
+};
+/**
+* Builds the client tree a generated client exposes. The generated file owns the
+* types; this owns the requests.
+*/
+const createGeneratedClient = (routes, config) => buildClientTree(routes, withContextHeaders(config));
+//#endregion
+exports.CLIENT_ROUTE = CLIENT_ROUTE;
+exports.createGeneratedClient = createGeneratedClient;
+Object.defineProperty(exports, "isProblemDetails", {
+	enumerable: true,
+	get: function() {
+		return kizunajs.isProblemDetails;
+	}
+});
+Object.defineProperty(exports, "isValidationError", {
+	enumerable: true,
+	get: function() {
+		return kizunajs.isValidationError;
+	}
+});
+exports.routeOf = routeOf;

package/dist/index.d.cts

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import { AUTO_GUARD_BRAND, AUTO_RESPONSES_BRAND, ExtractPathParams, HasPathParams, Method, ProblemDetails, RequestContextHeaderInputs, RouteDefinition, RoutePath, Routes, StreamMessageOf, StreamResponseDefinition, ValidationError, ValidationError as ValidationError$1, ValidationErrorFor, isProblemDetails, isValidationError } from "kizunajs";
+
+//#region src/client.d.ts
+type ResponseUnion<R extends RouteDefinition> = { [S in keyof R['responses']]: {
+  status: S extends number ? S : never;
+  body: R['responses'][S] extends z.ZodType ? z.infer<R['responses'][S]> : R['responses'][S] extends StreamResponseDefinition ? AsyncIterable<StreamMessageOf<R['responses'][S]>> : R['responses'][S] extends {
+    body: z.ZodType;
+  } ? z.infer<R['responses'][S]['body']> : never;
+  headers: R['responses'][S] extends {
+    headers: z.ZodType;
+  } ? z.infer<R['responses'][S]['headers']> : Record<string, string>;
+} }[keyof R['responses']];
+/**
+ * The type a caller passes for a body, query, or headers argument, the schema's
+ * input type.
+ */
+type ClientPayload<T extends z.ZodType> = z.input<T>;
+/**
+ * Path params are typed from the route's `pathParams` schema output when one is declared,
+ * mirroring the server-side `HandlerArgs`. This makes refinements like `.brand()` flow to
+ * the caller. Falls back to the path template (`:param` → `string`).
+ */
+type ClientParams<R extends RouteDefinition> = R extends {
+  pathParams: z.ZodType;
+} ? z.output<R['pathParams']> : ExtractPathParams<R['path']>;
+/**
+ * True when the arg can be omitted: its input accepts `{}` or `undefined`.
+ */
+type IsOmittable<Payload> = {} extends Payload ? true : [undefined] extends [Payload] ? true : false;
+/**
+ * Everything a caller passes for one route: `params`, `body`, `query`, `headers`,
+ * and `fetchOptions`. Each key is present only when the route declares it, and
+ * optional when its input accepts `{}` or `undefined`.
+ */
+type ClientArgs<R extends RouteDefinition> = (HasPathParams<R['path']> extends true ? {
+  params: ClientParams<R>;
+} : {}) & (R extends {
+  body: z.ZodType;
+} ? (ClientPayload<R['body']> extends void ? {} : {
+  body: ClientPayload<R['body']>;
+}) : {}) & (R extends {
+  query: z.ZodType;
+} ? IsOmittable<ClientPayload<R['query']>> extends true ? {
+  query?: ClientPayload<R['query']>;
+} : {
+  query: ClientPayload<R['query']>;
+} : {}) & (R extends {
+  headers: z.ZodType;
+} ? IsOmittable<ClientPayload<R['headers']>> extends true ? {
+  headers?: ClientPayload<R['headers']>;
+} : {
+  headers: ClientPayload<R['headers']>;
+} : {
+  headers?: Record<string, string>;
+}) & {
+  fetchOptions?: RequestInit;
+};
+type ValidationErrorResult<Codes extends string> = {
+  status: 400;
+  body: [Codes] extends [never] ? ValidationError$1 : ValidationErrorFor<Codes>;
+  headers: Record<string, string>;
+};
+type HasValidation<R extends RouteDefinition> = R extends {
+  body: z.ZodType;
+} ? true : R extends {
+  query: z.ZodType;
+} ? true : false;
+/**
+ * The statuses the api's auth map put on a guarded route. A declared `403`
+ * sits alongside, as a declared `400` does beside the validation error.
+ */
+type AutoStatuses<R extends RouteDefinition> = Extract<typeof AUTO_RESPONSES_BRAND extends keyof R ? NonNullable<R[typeof AUTO_RESPONSES_BRAND]> : never, number>;
+/**
+ * The api's `guardSchema`, or plain Problem Details when it declares none.
+ */
+type AutoBody<R extends RouteDefinition> = typeof AUTO_GUARD_BRAND extends keyof R ? NonNullable<R[typeof AUTO_GUARD_BRAND]> : ProblemDetails;
+type AutoErrorResult<R extends RouteDefinition> = { [Status in AutoStatuses<R>]: {
+  status: Status;
+  body: AutoBody<R>;
+  headers: Record<string, string>;
+} }[AutoStatuses<R>];
+/**
+ * Every response one route can produce, as a union discriminated on `status`.
+ * Routes with a `body` or `query` schema also carry the automatic `400`, and
+ * guarded routes the `401` and `403`.
+ */
+type ClientResponse<R extends RouteDefinition, Codes extends string = never> = (HasValidation<R> extends true ? ResponseUnion<R> | ValidationErrorResult<Codes> : ResponseUnion<R>) | AutoErrorResult<R>;
+type ClientFn<R extends RouteDefinition, Codes extends string> = {} extends ClientArgs<R> ? (args?: ClientArgs<R>) => Promise<ClientResponse<R, Codes>> : (args: ClientArgs<R>) => Promise<ClientResponse<R, Codes>>;
+type Client<T extends Routes, Codes extends string = never> = { [K in keyof T]: T[K] extends RouteDefinition ? ClientFn<T[K], Codes> : T[K] extends Routes ? Client<T[K], Codes> : never };
+type UnionToIntersection<Union> = (Union extends unknown ? (distributed: Union) => void : never) extends ((intersected: infer Intersection) => void) ? Intersection : never;
+/**
+ * Every header input the api's request context declares, flattened. Set
+ * once on the client under `requestContext` and sent with every request.
+ */
+type ContextHeaderInputs<Declarations> = string extends keyof Declarations ? {} : [keyof Declarations] extends [never] ? {} : UnionToIntersection<{ [Name in keyof Declarations]: RequestContextHeaderInputs<Declarations[Name]> }[keyof Declarations]> extends infer Merged ? { [Key in keyof Merged]: Merged[Key] } : never;
+/**
+ * The request `onRequest` is handed, on its way out. Setting a header on
+ * `headers` sets it on the request that is sent.
+ */
+interface OutgoingRequest {
+  url: string;
+  method: string;
+  headers: Headers;
+  route: RouteDefinition;
+}
+interface ClientConfig {
+  baseUrl: string;
+  baseHeaders?: Record<string, string>;
+  credentials?: RequestCredentials;
+  fetch?: typeof fetch;
+  onRequest?: (request: OutgoingRequest) => void | Promise<void>;
+}
+/**
+ * Registry-global: what a client method was built from. Anything wrapping a
+ * client reads the route here rather than being handed the api a second time.
+ */
+/**
+ * One method on a generated client: the call itself, carrying the method it
+ * sends and whether that response streams. A wrapper reads those off the client
+ * rather than being handed the routes a second time.
+ */
+type ClientMethod<Method extends string, Streams extends boolean, Args, Result> = ({} extends Args ? (args?: Args) => Promise<Result> : (args: Args) => Promise<Result>) & {
+  readonly [CLIENT_ROUTE]?: {
+    readonly method: Method;
+    readonly streams: Streams;
+  };
+};
+declare const CLIENT_ROUTE: unique symbol;
+/**
+ * The route a client method answers, or `undefined` for anything that is not
+ * one.
+ */
+declare const routeOf: (value: unknown) => RouteDefinition | undefined;
+/**
+ * What a generated client knows about one response: nothing for a body it
+ * parses as JSON, the media type for one it streams.
+ */
+type GeneratedResponse = Record<string, never> | {
+  stream: {
+    contentType?: string;
+  };
+};
+/**
+ * One route in a generated client's table: how to reach it, and enough about
+ * each response to read the body.
+ */
+interface GeneratedRoute {
+  method: Method;
+  path: RoutePath;
+  contentType?: string;
+  responses: Record<number, GeneratedResponse>;
+}
+/**
+ * The route table a generated client carries, nested the way the client is.
+ */
+interface GeneratedRoutes {
+  [key: string]: GeneratedRoutes | GeneratedRoute;
+}
+/**
+ * Builds the client tree a generated client exposes. The generated file owns the
+ * types; this owns the requests.
+ */
+declare const createGeneratedClient: (routes: GeneratedRoutes, config: ClientConfig) => Record<string, unknown>;
+//#endregion
+export { CLIENT_ROUTE, Client, ClientArgs, ClientConfig, ClientMethod, ClientResponse, ContextHeaderInputs, GeneratedResponse, GeneratedRoute, GeneratedRoutes, OutgoingRequest, type ValidationError, createGeneratedClient, isProblemDetails, isValidationError, routeOf };

package/dist/index.d.mts

@@ -0,0 +1,166 @@
+import { AUTO_GUARD_BRAND, AUTO_RESPONSES_BRAND, ExtractPathParams, HasPathParams, Method, ProblemDetails, RequestContextHeaderInputs, RouteDefinition, RoutePath, Routes, StreamMessageOf, StreamResponseDefinition, ValidationError, ValidationError as ValidationError$1, ValidationErrorFor, isProblemDetails, isValidationError } from "kizunajs";
+import { z } from "zod";
+
+//#region src/client.d.ts
+type ResponseUnion<R extends RouteDefinition> = { [S in keyof R['responses']]: {
+  status: S extends number ? S : never;
+  body: R['responses'][S] extends z.ZodType ? z.infer<R['responses'][S]> : R['responses'][S] extends StreamResponseDefinition ? AsyncIterable<StreamMessageOf<R['responses'][S]>> : R['responses'][S] extends {
+    body: z.ZodType;
+  } ? z.infer<R['responses'][S]['body']> : never;
+  headers: R['responses'][S] extends {
+    headers: z.ZodType;
+  } ? z.infer<R['responses'][S]['headers']> : Record<string, string>;
+} }[keyof R['responses']];
+/**
+ * The type a caller passes for a body, query, or headers argument, the schema's
+ * input type.
+ */
+type ClientPayload<T extends z.ZodType> = z.input<T>;
+/**
+ * Path params are typed from the route's `pathParams` schema output when one is declared,
+ * mirroring the server-side `HandlerArgs`. This makes refinements like `.brand()` flow to
+ * the caller. Falls back to the path template (`:param` → `string`).
+ */
+type ClientParams<R extends RouteDefinition> = R extends {
+  pathParams: z.ZodType;
+} ? z.output<R['pathParams']> : ExtractPathParams<R['path']>;
+/**
+ * True when the arg can be omitted: its input accepts `{}` or `undefined`.
+ */
+type IsOmittable<Payload> = {} extends Payload ? true : [undefined] extends [Payload] ? true : false;
+/**
+ * Everything a caller passes for one route: `params`, `body`, `query`, `headers`,
+ * and `fetchOptions`. Each key is present only when the route declares it, and
+ * optional when its input accepts `{}` or `undefined`.
+ */
+type ClientArgs<R extends RouteDefinition> = (HasPathParams<R['path']> extends true ? {
+  params: ClientParams<R>;
+} : {}) & (R extends {
+  body: z.ZodType;
+} ? (ClientPayload<R['body']> extends void ? {} : {
+  body: ClientPayload<R['body']>;
+}) : {}) & (R extends {
+  query: z.ZodType;
+} ? IsOmittable<ClientPayload<R['query']>> extends true ? {
+  query?: ClientPayload<R['query']>;
+} : {
+  query: ClientPayload<R['query']>;
+} : {}) & (R extends {
+  headers: z.ZodType;
+} ? IsOmittable<ClientPayload<R['headers']>> extends true ? {
+  headers?: ClientPayload<R['headers']>;
+} : {
+  headers: ClientPayload<R['headers']>;
+} : {
+  headers?: Record<string, string>;
+}) & {
+  fetchOptions?: RequestInit;
+};
+type ValidationErrorResult<Codes extends string> = {
+  status: 400;
+  body: [Codes] extends [never] ? ValidationError$1 : ValidationErrorFor<Codes>;
+  headers: Record<string, string>;
+};
+type HasValidation<R extends RouteDefinition> = R extends {
+  body: z.ZodType;
+} ? true : R extends {
+  query: z.ZodType;
+} ? true : false;
+/**
+ * The statuses the api's auth map put on a guarded route. A declared `403`
+ * sits alongside, as a declared `400` does beside the validation error.
+ */
+type AutoStatuses<R extends RouteDefinition> = Extract<typeof AUTO_RESPONSES_BRAND extends keyof R ? NonNullable<R[typeof AUTO_RESPONSES_BRAND]> : never, number>;
+/**
+ * The api's `guardSchema`, or plain Problem Details when it declares none.
+ */
+type AutoBody<R extends RouteDefinition> = typeof AUTO_GUARD_BRAND extends keyof R ? NonNullable<R[typeof AUTO_GUARD_BRAND]> : ProblemDetails;
+type AutoErrorResult<R extends RouteDefinition> = { [Status in AutoStatuses<R>]: {
+  status: Status;
+  body: AutoBody<R>;
+  headers: Record<string, string>;
+} }[AutoStatuses<R>];
+/**
+ * Every response one route can produce, as a union discriminated on `status`.
+ * Routes with a `body` or `query` schema also carry the automatic `400`, and
+ * guarded routes the `401` and `403`.
+ */
+type ClientResponse<R extends RouteDefinition, Codes extends string = never> = (HasValidation<R> extends true ? ResponseUnion<R> | ValidationErrorResult<Codes> : ResponseUnion<R>) | AutoErrorResult<R>;
+type ClientFn<R extends RouteDefinition, Codes extends string> = {} extends ClientArgs<R> ? (args?: ClientArgs<R>) => Promise<ClientResponse<R, Codes>> : (args: ClientArgs<R>) => Promise<ClientResponse<R, Codes>>;
+type Client<T extends Routes, Codes extends string = never> = { [K in keyof T]: T[K] extends RouteDefinition ? ClientFn<T[K], Codes> : T[K] extends Routes ? Client<T[K], Codes> : never };
+type UnionToIntersection<Union> = (Union extends unknown ? (distributed: Union) => void : never) extends ((intersected: infer Intersection) => void) ? Intersection : never;
+/**
+ * Every header input the api's request context declares, flattened. Set
+ * once on the client under `requestContext` and sent with every request.
+ */
+type ContextHeaderInputs<Declarations> = string extends keyof Declarations ? {} : [keyof Declarations] extends [never] ? {} : UnionToIntersection<{ [Name in keyof Declarations]: RequestContextHeaderInputs<Declarations[Name]> }[keyof Declarations]> extends infer Merged ? { [Key in keyof Merged]: Merged[Key] } : never;
+/**
+ * The request `onRequest` is handed, on its way out. Setting a header on
+ * `headers` sets it on the request that is sent.
+ */
+interface OutgoingRequest {
+  url: string;
+  method: string;
+  headers: Headers;
+  route: RouteDefinition;
+}
+interface ClientConfig {
+  baseUrl: string;
+  baseHeaders?: Record<string, string>;
+  credentials?: RequestCredentials;
+  fetch?: typeof fetch;
+  onRequest?: (request: OutgoingRequest) => void | Promise<void>;
+}
+/**
+ * Registry-global: what a client method was built from. Anything wrapping a
+ * client reads the route here rather than being handed the api a second time.
+ */
+/**
+ * One method on a generated client: the call itself, carrying the method it
+ * sends and whether that response streams. A wrapper reads those off the client
+ * rather than being handed the routes a second time.
+ */
+type ClientMethod<Method extends string, Streams extends boolean, Args, Result> = ({} extends Args ? (args?: Args) => Promise<Result> : (args: Args) => Promise<Result>) & {
+  readonly [CLIENT_ROUTE]?: {
+    readonly method: Method;
+    readonly streams: Streams;
+  };
+};
+declare const CLIENT_ROUTE: unique symbol;
+/**
+ * The route a client method answers, or `undefined` for anything that is not
+ * one.
+ */
+declare const routeOf: (value: unknown) => RouteDefinition | undefined;
+/**
+ * What a generated client knows about one response: nothing for a body it
+ * parses as JSON, the media type for one it streams.
+ */
+type GeneratedResponse = Record<string, never> | {
+  stream: {
+    contentType?: string;
+  };
+};
+/**
+ * One route in a generated client's table: how to reach it, and enough about
+ * each response to read the body.
+ */
+interface GeneratedRoute {
+  method: Method;
+  path: RoutePath;
+  contentType?: string;
+  responses: Record<number, GeneratedResponse>;
+}
+/**
+ * The route table a generated client carries, nested the way the client is.
+ */
+interface GeneratedRoutes {
+  [key: string]: GeneratedRoutes | GeneratedRoute;
+}
+/**
+ * Builds the client tree a generated client exposes. The generated file owns the
+ * types; this owns the requests.
+ */
+declare const createGeneratedClient: (routes: GeneratedRoutes, config: ClientConfig) => Record<string, unknown>;
+//#endregion
+export { CLIENT_ROUTE, Client, ClientArgs, ClientConfig, ClientMethod, ClientResponse, ContextHeaderInputs, GeneratedResponse, GeneratedRoute, GeneratedRoutes, OutgoingRequest, type ValidationError, createGeneratedClient, isProblemDetails, isValidationError, routeOf };