@shipworthy/openapi-fetch 0.0.1 → 1.0.0

package/dist/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region src/headers.ts
+// src/headers.ts
 /** Iterate any `HeadersOptions` form (plain object, `Headers`, or `[name, value]` tuples) as entries */
 function headerEntries(h) {
 	if (h instanceof Headers) return h.entries();
@@ -20,8 +20,166 @@ function mergeHeaders(...allHeaders) {
 	}
 	return finalHeaders;
 }
-//#endregion
-//#region src/serializers/body.ts
+// src/middleware/transform-casing.ts
+function expandSchemas(schemas, mapping, visited = /* @__PURE__ */ new Set()) {
+	return schemas.flatMap((schema) => {
+		const nested = schema.variants ?? [];
+		if (!schema.ref || visited.has(schema.ref)) return [schema, ...expandSchemas(nested, mapping, visited)];
+		const referenced = mapping.schemas?.[schema.ref];
+		const next = new Set(visited).add(schema.ref);
+		return [schema, ...expandSchemas(referenced ? [referenced, ...nested] : nested, mapping, next)];
+	});
+}
+function createConverter(mapping) {
+	const schemaIds = /* @__PURE__ */ new WeakMap();
+	const plans = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	function planFor(schemas, direction) {
+		if (schemas.length === 0) return void 0;
+		const key = `${direction}:${schemas.map((schema) => {
+			let id = schemaIds.get(schema);
+			if (id === void 0) {
+				id = ++nextId;
+				schemaIds.set(schema, id);
+			}
+			return id;
+		}).join(",")}`;
+		const existing = plans.get(key);
+		if (existing) return existing;
+		const expanded = expandSchemas(schemas, mapping);
+		const fields = /* @__PURE__ */ new Map();
+		for (const schema of expanded) for (const [wireName, field] of Object.entries(schema.properties ?? {})) {
+			const sourceName = direction === "toApi" ? field.name : wireName;
+			const targetName = direction === "toApi" ? wireName : field.name;
+			const current = fields.get(sourceName);
+			if (current) {
+				if (current.name !== targetName) throw new Error(`Conflicting case mapping for ${sourceName}`);
+				if (field.schema) current.schemas.push(field.schema);
+			} else fields.set(sourceName, {
+				name: targetName,
+				schemas: field.schema ? [field.schema] : []
+			});
+		}
+		const plan = {
+			expanded,
+			fields,
+			declared: new Set(expanded.flatMap((schema) => schema.declared ?? [])),
+			patterns: expanded.flatMap((schema) => Object.entries(schema.patternProperties ?? {}).map(([pattern, nested]) => ({
+				regex: new RegExp(pattern),
+				schema: nested
+			}))),
+			additional: expanded.flatMap((schema) => schema.additionalProperties ? [schema.additionalProperties] : []),
+			prefixLength: expanded.reduce((max, schema) => Math.max(max, schema.prefixItems?.length ?? 0), 0)
+		};
+		plans.set(key, plan);
+		return plan;
+	}
+	function itemPlan(plan, index, direction) {
+		if (index >= plan.prefixLength) {
+			if (plan.items === void 0) plan.items = planFor(plan.expanded.flatMap((schema) => schema.items ? [schema.items] : []), direction) ?? null;
+			return plan.items ?? void 0;
+		}
+		const prefixItems = plan.prefixItems ??= [];
+		if (prefixItems[index] === void 0) prefixItems[index] = planFor(plan.expanded.flatMap((schema) => {
+			const prefix = schema.prefixItems;
+			const item = prefix && index < prefix.length ? prefix[index] : schema.items;
+			return item ? [item] : [];
+		}), direction) ?? null;
+		return prefixItems[index] ?? void 0;
+	}
+	function convertWithPlan(value, plan, direction) {
+		if (!plan || value === null || value === void 0) return value;
+		if (Array.isArray(value)) return value.map((item, index) => convertWithPlan(item, itemPlan(plan, index, direction), direction));
+		if (typeof value !== "object") return value;
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) return value;
+		const convertedNames = /* @__PURE__ */ new Set();
+		const entries = Object.entries(value).map(([name, item]) => {
+			const field = plan.fields.get(name);
+			const matched = [];
+			let hasPattern = false;
+			for (const pattern of plan.patterns) if (pattern.regex.test(name)) {
+				hasPattern = true;
+				if (pattern.schema) matched.push(pattern.schema);
+			}
+			let nested;
+			if (matched.length > 0) nested = planFor([...field?.schemas ?? [], ...matched], direction);
+			else if (field) {
+				if (field.nested === void 0) field.nested = planFor(field.schemas, direction) ?? null;
+				nested = field.nested ?? void 0;
+			} else if (!plan.declared.has(name) && !hasPattern) {
+				if (plan.additionalPlan === void 0) plan.additionalPlan = planFor(plan.additional, direction) ?? null;
+				nested = plan.additionalPlan ?? void 0;
+			}
+			const targetName = field?.name ?? name;
+			if (convertedNames.has(targetName)) throw new Error(`Conflicting case mapping for ${targetName}`);
+			convertedNames.add(targetName);
+			return [targetName, convertWithPlan(item, nested, direction)];
+		});
+		return Object.fromEntries(entries);
+	}
+	return (value, schemas, direction) => {
+		if (schemas.length === 0 || value === null || value === void 0) return value;
+		return convertWithPlan(value, planFor(schemas, direction), direction);
+	};
+}
+function isJsonMediaType(mediaType) {
+	return mediaType === "application/json" || mediaType.endsWith("+json");
+}
+function mediaSchema(media, contentType) {
+	if (!media) return void 0;
+	const type = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+	if (type && !isJsonMediaType(type)) return void 0;
+	const entries = Object.entries(media).filter(([name]) => isJsonMediaType(name.toLowerCase()));
+	const exact = entries.find(([name]) => name.toLowerCase() === type);
+	if (exact) return exact[1] ?? void 0;
+	const json = entries.find(([name]) => name.toLowerCase() === "application/json");
+	if (json) return json[1] ?? void 0;
+	return entries.length === 1 ? entries[0]?.[1] ?? void 0 : void 0;
+}
+function responseMedia(operation, response) {
+	const responses = operation.responses;
+	if (!responses) return void 0;
+	const status = String(response.status);
+	const range = `${status[0]}XX`;
+	return mediaSchema(Object.hasOwn(responses, status) ? responses[status] : Object.hasOwn(responses, range) ? responses[range] : responses.default, response.headers.get("content-type") ?? void 0);
+}
+function convertRequest(input, operation, convertValue, headers) {
+	const parameters = operation.parameters;
+	const params = input.params;
+	const bodySchema = mediaSchema(operation.requestBodies, headers.get("content-type") ?? void 0);
+	return {
+		params: parameters ? {
+			...params,
+			path: convertValue(params.path, parameters.path ? [parameters.path] : [], "toApi"),
+			query: convertValue(params.query, parameters.query ? [parameters.query] : [], "toApi"),
+			header: convertValue(params.header, parameters.header ? [parameters.header] : [], "toApi"),
+			cookie: convertValue(params.cookie, parameters.cookie ? [parameters.cookie] : [], "toApi")
+		} : params,
+		body: bodySchema && input.body !== void 0 ? convertValue(input.body, [bodySchema], "toApi") : input.body
+	};
+}
+/** Convert generated camelCase values at the openapi-fetch request and result stages. */
+function createCaseMappingMiddleware(mapping) {
+	const convertValue = createConverter(mapping);
+	return {
+		onRequestInit({ method, schemaPath, input, headers }) {
+			const operation = mapping.operations?.[`${method} ${schemaPath}`];
+			return operation ? convertRequest(input, operation, convertValue, headers) : void 0;
+		},
+		onResult({ method, schemaPath, result, options }) {
+			const operation = mapping.operations?.[`${method} ${schemaPath}`];
+			if (!operation) return;
+			const schema = responseMedia(operation, result.response);
+			if (!schema) return;
+			return {
+				...options.parseAs === "json" && result.data !== void 0 ? { data: convertValue(result.data, [schema], "fromApi") } : {},
+				...result.error !== void 0 ? { error: convertValue(result.error, [schema], "fromApi") } : {}
+			};
+		}
+	};
+}
+// src/serializers/body.ts
 /** Serialize body object to string */
 function defaultBodySerializer(body, headers) {
 	if (body instanceof FormData) return body;
@@ -30,8 +188,7 @@ function defaultBodySerializer(body, headers) {
 	}
 	return JSON.stringify(body);
 }
-//#endregion
-//#region src/serializers/param.ts
+// src/serializers/param.ts
 /** Serialize primitive params to string */
 function serializePrimitiveParam(name, value, options) {
 	if (value === void 0 || value === null) return "";
@@ -91,8 +248,7 @@ function serializeArrayParam(name, value, options) {
 	else values.push(serializePrimitiveParam(name, v, options));
 	return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
 }
-//#endregion
-//#region src/serializers/cookie.ts
+// src/serializers/cookie.ts
 /**
 * Serialize cookie params to a `Cookie` header value using the OpenAPI default
 * (style: form, explode: true). Arrays repeat the name, objects emit one pair per key,
@@ -114,8 +270,7 @@ function serializeCookieParams(cookieParams) {
 	}
 	return pairs.join("; ");
 }
-//#endregion
-//#region src/serializers/path.ts
+// src/serializers/path.ts
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
 /**
 * Handle different OpenAPI 3.x serialization styles
@@ -162,8 +317,7 @@ function defaultPathSerializer(pathname, pathParams) {
 	}
 	return nextURL;
 }
-//#endregion
-//#region src/serializers/query.ts
+// src/serializers/query.ts
 /** Serialize query params to string */
 function createQuerySerializer(options) {
 	return function querySerializer(queryParams) {
@@ -195,8 +349,7 @@ function createQuerySerializer(options) {
 		return search.join("&");
 	};
 }
-//#endregion
-//#region src/serializers/url.ts
+// src/serializers/url.ts
 /** Construct URL string from baseUrl and handle path and query params */
 function createFinalURL(pathname, options) {
 	let finalURL = `${options.baseUrl}${pathname}`;
@@ -211,8 +364,7 @@ function removeTrailingSlash(url) {
 	if (url.endsWith("/")) return url.substring(0, url.length - 1);
 	return url;
 }
-//#endregion
-//#region src/client.ts
+// src/client.ts
 function supportsRequestInitExt() {
 	const nodeProcess = globalThis.process;
 	return typeof nodeProcess === "object" && Number.parseInt(nodeProcess?.versions?.node?.substring(0, 2) ?? "") >= 18 && nodeProcess?.versions?.undici;
@@ -225,15 +377,16 @@ function randomID() {
 * Create an openapi-fetch client.
 */
 function createClient(clientOptions) {
-	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, headers: baseHeaders, requestInitExt, ...baseOptions } = { ...clientOptions };
+	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, caseMapping, headers: baseHeaders, requestInitExt, ...baseOptions } = { ...clientOptions };
 	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
 	baseUrl = removeTrailingSlash(baseUrl);
 	const globalMiddlewares = [];
+	if (caseMapping !== void 0) globalMiddlewares.push(createCaseMappingMiddleware(caseMapping));
 	/**
 	* Per-request fetch (keeps settings created in createClient()
 	*/
 	async function coreFetch(schemaPath, fetchOptions) {
-		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
+		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params: initialParams = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body: initialBody, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
 		let finalBaseUrl = baseUrl;
 		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
 		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
@@ -242,6 +395,41 @@ function createClient(clientOptions) {
 			...requestQuerySerializer
 		});
 		const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+		const method = String(init.method ?? "GET").toUpperCase();
+		let id;
+		let options;
+		let params = initialParams;
+		let body = initialBody;
+		if (finalMiddlewares.length) {
+			id = randomID();
+			options = Object.freeze({
+				baseUrl: finalBaseUrl,
+				fetch,
+				parseAs,
+				querySerializer,
+				bodySerializer,
+				pathSerializer
+			});
+			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequestInit === "function") {
+				const result = await m.onRequestInit({
+					schemaPath,
+					method,
+					input: {
+						params,
+						body
+					},
+					headers: mergeHeaders(baseHeaders, headers, params.header),
+					options,
+					id
+				});
+				if (result !== void 0) {
+					if (!result || typeof result !== "object" || !("params" in result) || !("body" in result)) throw new Error("onRequestInit: must return request input when modifying it");
+					params = result.params;
+					body = result.body;
+				}
+			}
+		}
 		const serializedBody = body === void 0 ? void 0 : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
 		const finalHeaders = mergeHeaders(serializedBody === void 0 || serializedBody instanceof FormData ? {} : { "Content-Type": "application/json" }, baseHeaders, headers, params.header);
 		const serializedCookies = serializeCookieParams(params.cookie);
@@ -249,7 +437,6 @@ function createClient(clientOptions) {
 			const existingCookie = finalHeaders.get("Cookie");
 			finalHeaders.set("Cookie", existingCookie ? `${existingCookie}; ${serializedCookies}` : serializedCookies);
 		}
-		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
 		const requestInit = {
 			redirect: "follow",
 			...baseOptions,
@@ -257,8 +444,6 @@ function createClient(clientOptions) {
 			body: serializedBody,
 			headers: finalHeaders
 		};
-		let id;
-		let options;
 		let request = new Request(createFinalURL(schemaPath, {
 			baseUrl: finalBaseUrl,
 			params,
@@ -269,15 +454,6 @@ function createClient(clientOptions) {
 		/** Add custom parameters to Request object */
 		for (const key in init) if (!(key in request)) request[key] = init[key];
 		if (finalMiddlewares.length) {
-			id = randomID();
-			options = Object.freeze({
-				baseUrl: finalBaseUrl,
-				fetch,
-				parseAs,
-				querySerializer,
-				bodySerializer,
-				pathSerializer
-			});
 			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequest === "function") {
 				const result = await m.onRequest({
 					request,
@@ -346,14 +522,15 @@ function createClient(clientOptions) {
 		}
 		const finalResponse = response;
 		const contentLength = finalResponse.headers.get("Content-Length");
-		if (finalResponse.status === 204 || request.method === "HEAD" || contentLength === "0" && !finalResponse.headers.get("Transfer-Encoding")?.includes("chunked")) return finalResponse.ok ? {
+		let parsedResult;
+		if (finalResponse.status === 204 || request.method === "HEAD" || contentLength === "0" && !finalResponse.headers.get("Transfer-Encoding")?.includes("chunked")) parsedResult = finalResponse.ok ? {
 			data: void 0,
 			response: finalResponse
 		} : {
 			error: void 0,
 			response: finalResponse
 		};
-		if (finalResponse.ok) {
+		else if (finalResponse.ok) {
 			const getResponseData = async () => {
 				if (parseAs === "stream") return finalResponse.body;
 				if (parseAs === "json" && !contentLength) {
@@ -362,24 +539,50 @@ function createClient(clientOptions) {
 				}
 				return await finalResponse[parseAs]();
 			};
-			return {
+			parsedResult = {
 				data: await getResponseData(),
 				response: finalResponse
 			};
+		} else {
+			const raw = await finalResponse.text();
+			if (!raw) parsedResult = {
+				error: void 0,
+				response: finalResponse
+			};
+			else {
+				let error = raw;
+				try {
+					error = JSON.parse(raw);
+				} catch {}
+				parsedResult = {
+					error,
+					response: finalResponse
+				};
+			}
 		}
-		const raw = await finalResponse.text();
-		if (!raw) return {
-			error: void 0,
-			response: finalResponse
-		};
-		let error = raw;
-		try {
-			error = JSON.parse(raw);
-		} catch {}
-		return {
-			error,
-			response: finalResponse
-		};
+		for (let index = finalMiddlewares.length - 1; index >= 0; index--) {
+			const m = finalMiddlewares[index];
+			if (m && typeof m === "object" && typeof m.onResult === "function") {
+				const update = await m.onResult({
+					request,
+					schemaPath,
+					method,
+					params,
+					options,
+					id,
+					result: parsedResult
+				});
+				if (update !== void 0) {
+					if (!update || typeof update !== "object" || Object.keys(update).some((key) => key !== "data" && key !== "error")) throw new Error("onResult: must return data and/or error when modifying the result");
+					parsedResult = {
+						...parsedResult,
+						...update,
+						response: finalResponse
+					};
+				}
+			}
+		}
+		return parsedResult;
 	}
 	return {
 		request(method, url, init) {
@@ -448,7 +651,7 @@ function createClient(clientOptions) {
 		use(...middleware) {
 			for (const m of middleware) {
 				if (!m) continue;
-				if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+				if (typeof m !== "object" || !("onRequestInit" in m || "onRequest" in m || "onResponse" in m || "onError" in m || "onResult" in m)) throw new Error("Middleware must be an object with a supported hook");
 				globalMiddlewares.push(m);
 			}
 		},
@@ -461,8 +664,7 @@ function createClient(clientOptions) {
 		}
 	};
 }
-//#endregion
-//#region src/path-client.ts
+// src/path-client.ts
 var PathCallForwarder = class {
 	client;
 	url;
@@ -522,7 +724,6 @@ function wrapAsPathBasedClient(coreClient) {
 function createPathBasedClient(clientOptions) {
 	return wrapAsPathBasedClient(createClient(clientOptions));
 }
-//#endregion
 exports.createClient = createClient;
 exports.createFinalURL = createFinalURL;
 exports.createPathBasedClient = createPathBasedClient;

package/dist/index.d.cts

@@ -1,4 +1,3 @@
-//#region src/helpers.d.ts
 type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
 /** 2XX statuses */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
@@ -190,8 +189,29 @@ type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Re
  * - object → recursively resolve
  */
 type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends (infer E)[] ? Writable<E>[] : T extends object ? { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]>; } & { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never; } : T;
-//#endregion
-//#region src/types.d.ts
+interface CaseSchema {
+  readonly ref?: string;
+  readonly properties?: Readonly<Record<string, {
+    readonly name: string;
+    readonly schema?: CaseSchema;
+  }>>;
+  readonly declared?: readonly string[];
+  readonly items?: CaseSchema;
+  readonly prefixItems?: readonly (CaseSchema | null)[];
+  readonly additionalProperties?: CaseSchema;
+  readonly patternProperties?: Readonly<Record<string, CaseSchema | null>>;
+  readonly variants?: readonly CaseSchema[];
+}
+type CaseMediaMap = Readonly<Record<string, CaseSchema | null>>;
+interface CaseOperation {
+  readonly parameters?: Readonly<Partial<Record<"path" | "query" | "header" | "cookie", CaseSchema>>>;
+  readonly requestBodies?: CaseMediaMap;
+  readonly responses?: Readonly<Record<string, CaseMediaMap | null>>;
+}
+interface CaseMapping {
+  readonly schemas?: Readonly<Record<string, CaseSchema>>;
+  readonly operations?: Readonly<Record<string, CaseOperation>>;
+}
 /** Options for each client instance */
 interface ClientOptions extends Omit<RequestInit, "headers"> {
   /** set the common root URL for all API requests */
@@ -206,6 +226,8 @@ interface ClientOptions extends Omit<RequestInit, "headers"> {
   bodySerializer?: BodySerializer<unknown>;
   /** global pathSerializer */
   pathSerializer?: PathSerializer;
+  /** schema-based field mapping applied to every request and parsed result */
+  caseMapping?: CaseMapping;
   headers?: HeadersOptions;
   /** RequestInit extension object to pass as 2nd argument to fetch when supported (defaults to undefined) */
   requestInitExt?: Record<string, unknown>;
@@ -301,10 +323,28 @@ type MergedOptions<T = unknown> = {
 };
 interface MiddlewareRequestParams {
   query?: Record<string, unknown>;
-  header?: Record<string, unknown>;
+  header?: HeadersOptions;
   path?: Record<string, unknown>;
   cookie?: Record<string, unknown>;
 }
+interface MiddlewareRequestInput {
+  readonly params: MiddlewareRequestParams;
+  readonly body: unknown;
+}
+interface MiddlewareRequestInitParams {
+  readonly schemaPath: string;
+  readonly method: string;
+  readonly input: MiddlewareRequestInput;
+  /** Client, request, and parameter headers merged before serialization. */
+  readonly headers: Headers;
+  readonly id: string;
+  readonly options: MergedOptions;
+}
+interface MiddlewareResult {
+  readonly data?: unknown;
+  readonly error?: unknown;
+  readonly response: Response;
+}
 interface MiddlewareCallbackParams {
   /** Current Request object */
   request: Request;
@@ -317,6 +357,12 @@ interface MiddlewareCallbackParams {
   /** createClient options (read-only) */
   readonly options: MergedOptions;
 }
+interface MiddlewareResultParams extends MiddlewareCallbackParams {
+  /** The method requested through the client, before HTTP middleware can replace the Request. */
+  readonly method: string;
+  readonly result: MiddlewareResult;
+}
+type MiddlewareOnRequestInit = (options: MiddlewareRequestInitParams) => void | MiddlewareRequestInput | Promise<MiddlewareRequestInput | void>;
 type MiddlewareOnRequest = (options: MiddlewareCallbackParams) => void | Request | Response | undefined | Promise<Request | Response | undefined | void>;
 type MiddlewareOnResponse = (options: MiddlewareCallbackParams & {
   response: Response;
@@ -324,19 +370,25 @@ type MiddlewareOnResponse = (options: MiddlewareCallbackParams & {
 type MiddlewareOnError = (options: MiddlewareCallbackParams & {
   error: unknown;
 }) => void | Response | Error | Promise<void | Response | Error>;
-type Middleware = {
-  onRequest: MiddlewareOnRequest;
+type MiddlewareOnResult = (options: MiddlewareResultParams) => void | Partial<Pick<MiddlewareResult, "data" | "error">> | Promise<Partial<Pick<MiddlewareResult, "data" | "error">> | void>;
+interface MiddlewareHooks {
+  onRequestInit?: MiddlewareOnRequestInit;
+  onRequest?: MiddlewareOnRequest;
   onResponse?: MiddlewareOnResponse;
   onError?: MiddlewareOnError;
+  onResult?: MiddlewareOnResult;
+}
+type Middleware = MiddlewareHooks & ({
+  onRequestInit: MiddlewareOnRequestInit;
+} | {
+  onRequest: MiddlewareOnRequest;
 } | {
-  onRequest?: MiddlewareOnRequest;
   onResponse: MiddlewareOnResponse;
-  onError?: MiddlewareOnError;
 } | {
-  onRequest?: MiddlewareOnRequest;
-  onResponse?: MiddlewareOnResponse;
   onError: MiddlewareOnError;
-};
+} | {
+  onResult: MiddlewareOnResult;
+});
 /** This type helper makes the 2nd function param required if params/requestBody are required; otherwise, optional */
 type MaybeOptionalInit<Params, Location extends keyof Params> = RequiredKeysOf<FetchOptions<FilterKeys<Params, Location>>> extends never ? FetchOptions<FilterKeys<Params, Location>> | undefined : FetchOptions<FilterKeys<Params, Location>>;
 type InitParam<Init> = RequiredKeysOf<Init> extends never ? [(Init & {
@@ -375,14 +427,10 @@ type MethodResponse<CreatedClient extends Client<any, any>, Method extends HttpM
   [key: string]: any;
 }, infer Media extends MediaType> ? NonNullable<FetchResponse<Paths[Path][Method], Options, Media>["data"]> : never;
 type PathBasedClient<Paths extends Record<string | number, any>, Media extends MediaType = MediaType> = { [Path in keyof Paths]: ClientForPath<Paths[Path], Media>; };
-//#endregion
-//#region src/client.d.ts
 /**
  * Create an openapi-fetch client.
  */
 export default function createClient<Paths extends {}, Media extends MediaType = MediaType>(clientOptions?: ClientOptions): Client<Paths, Media>;
-//#endregion
-//#region src/path-client.d.ts
 /**
  * Wrap openapi-fetch client to support a path based API.
  */
@@ -392,12 +440,8 @@ export declare function wrapAsPathBasedClient<Paths extends {}, Media extends Me
  * Strictly equivalent to `wrapAsPathBasedClient(createClient(...))`.
  */
 export declare function createPathBasedClient<Paths extends {}, Media extends MediaType = MediaType>(clientOptions?: ClientOptions): PathBasedClient<Paths, Media>;
-//#endregion
-//#region src/headers.d.ts
 /** Merge headers a and b, with b taking priority */
 export declare function mergeHeaders(...allHeaders: (HeadersOptions | undefined)[]): Headers;
-//#endregion
-//#region src/serializers/param.d.ts
 type SerializePrimitiveOptions = {
   allowReserved?: boolean;
 };
@@ -417,23 +461,15 @@ type SerializeArrayOptions = {
 };
 /** Serialize array param (shallow only) */
 export declare function serializeArrayParam(name: string, value: unknown[], options: SerializeArrayOptions): string;
-//#endregion
-//#region src/serializers/query.d.ts
 /** Serialize query params to string */
 export declare function createQuerySerializer<T = unknown>(options?: QuerySerializerOptions): (queryParams: T) => string;
-//#endregion
-//#region src/serializers/path.d.ts
 /**
  * Handle different OpenAPI 3.x serialization styles
  * @see https://swagger.io/docs/specification/serialization/#path
  */
 export declare function defaultPathSerializer(pathname: string, pathParams: Record<string, unknown>): string;
-//#endregion
-//#region src/serializers/body.d.ts
 /** Serialize body object to string */
 export declare function defaultBodySerializer<T>(body: T, headers?: Headers | Record<string, unknown>): string | FormData;
-//#endregion
-//#region src/serializers/url.d.ts
 /** Construct URL string from baseUrl and handle path and query params */
 export declare function createFinalURL<O>(pathname: string, options: {
   baseUrl: string;
@@ -446,5 +482,4 @@ export declare function createFinalURL<O>(pathname: string, options: {
 }): string;
 /** Remove trailing slash from url */
 export declare function removeTrailingSlash(url: string): string;
-//#endregion
-export { type $Read, type $Write, type BodySerializer, type Client, type ClientForPath, type ClientMethod, type ClientOptions, type ClientPathsWithMethod, type ClientRequestMethod, type DefaultParamsOption, type ErrorResponse, type ErrorResponseJSON, type ErrorStatus, type FetchOptions, type FetchResponse, type FilterKeys, type FirstErrorStatus, type GetResponseContent, type HeadersOptions, type HttpMethod, type IsOperationRequestBodyOptional, type JSONLike, type MaybeOptionalInit, type MediaType, type MergedOptions, type MethodResponse, type Middleware, type MiddlewareCallbackParams, type MiddlewareRequestParams, type OKStatusUnion, type OkStatus, type OperationObject, type OperationRequestBody, type OperationRequestBodyContent, type OperationRequestBodyMediaContent, type ParamsOption, type ParseAs, type ParseAsResponse, type PathBasedClient, type PathItemObject, type PathSerializer, type PathsWithMethod, type QuerySerializer, type QuerySerializerOptions, type Readable, type RequestBodyJSON, type RequestBodyOption, type RequestOptions, type RequiredKeysOf, type ResponseContent, type ResponseObjectMap, type SuccessResponse, type SuccessResponseJSON, type Writable, createClient };
+export { type $Read, type $Write, type BodySerializer, type Client, type ClientForPath, type ClientMethod, type ClientOptions, type ClientPathsWithMethod, type ClientRequestMethod, type DefaultParamsOption, type ErrorResponse, type ErrorResponseJSON, type ErrorStatus, type FetchOptions, type FetchResponse, type FilterKeys, type FirstErrorStatus, type GetResponseContent, type HeadersOptions, type HttpMethod, type IsOperationRequestBodyOptional, type JSONLike, type MaybeOptionalInit, type MediaType, type MergedOptions, type MethodResponse, type Middleware, type MiddlewareCallbackParams, type MiddlewareRequestInitParams, type MiddlewareRequestInput, type MiddlewareRequestParams, type MiddlewareResult, type MiddlewareResultParams, type OKStatusUnion, type OkStatus, type OperationObject, type OperationRequestBody, type OperationRequestBodyContent, type OperationRequestBodyMediaContent, type ParamsOption, type ParseAs, type ParseAsResponse, type PathBasedClient, type PathItemObject, type PathSerializer, type PathsWithMethod, type QuerySerializer, type QuerySerializerOptions, type Readable, type RequestBodyJSON, type RequestBodyOption, type RequestOptions, type RequiredKeysOf, type ResponseContent, type ResponseObjectMap, type SuccessResponse, type SuccessResponseJSON, type Writable, createClient };