@kubb/plugin-client 5.0.0-beta.42 → 5.0.0-beta.64

package/dist/index.js

@@ -4,8 +4,9 @@ import { source as source$1 } from "./templates/clients/fetch.source.js";
 import { source as source$2 } from "./templates/config.source.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { buildJSDoc, caseParams, createOperationParams, stringify } from "@kubb/ast/utils";
 import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Const, File, Function, jsxRendererSync } from "@kubb/renderer-jsx";
+import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { pluginZodName } from "@kubb/plugin-zod";
 //#region ../../internals/utils/src/casing.ts
@@ -19,68 +20,57 @@ import { pluginZodName } from "@kubb/plugin-zod";
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
 * Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/jsdoc.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Builds a JSDoc comment block from an array of lines.
-* Returns `fallback` when `comments` is empty so callers always get a usable string.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @example
-* ```ts
-* buildJSDoc(['@type string', '@example hello'])
-* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
-* ```
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function buildJSDoc(comments, options = {}) {
-	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
-	if (comments.length === 0) return fallback;
-	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -206,99 +196,83 @@ function ensureValidVarName(name) {
 	return `_${name}`;
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
 */
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
+var Url$1 = class Url$1 {
+	static {
+		__name(this, "Url");
 	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	/**
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
 	*/
-	get URL() {
-		return this.toURLPath();
+	static canParse(url, base) {
+		return URL.canParse(url, base);
 	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
 	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
 	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
 	*
 	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	get object() {
-		return this.toObject();
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
-	/** Returns a map of path parameter names, or `null` when the path has no parameters.
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // null
-	* ```
-	*/
-	get params() {
-		return this.toParamsObject();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
 		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.toParamsObject()
+			url: type === "path" ? Url$1.toPath(path) : Url$1.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -307,50 +281,6 @@ var URLPath = class {
 		}
 		return object;
 	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix, replacer } = {}) {
-		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	toParamsObject(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : null;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
 };
 //#endregion
 //#region ../../internals/shared/src/operation.ts
@@ -376,7 +306,7 @@ function operationFileEntry(node, name, extname = ".ts") {
 function getOperationLink(node, link) {
 	if (!link) return null;
 	if (typeof link === "function") return link(node) ?? null;
-	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : null;
+	if (link === "urlPath") return node.path ? `{@link ${Url$1.toPath(node.path)}}` : null;
 	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
 function getContentTypeInfo(node) {
@@ -429,7 +359,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -467,6 +397,19 @@ function resolveSuccessNames(node, resolver) {
 function resolveStatusCodeNames(node, resolver) {
 	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
 }
+/**
+* Builds the discriminated union type string for `dataReturnType: 'full'` return shapes.
+* Each member is `{ status: N; data: StatusNType; statusText: string }`.
+*/
+function buildStatusUnionType(node, resolver) {
+	const members = node.responses.map((r) => {
+		const typeName = resolver.resolveResponseStatusName(node, r.statusCode);
+		const statusCode = Number.parseInt(r.statusCode, 10);
+		return `{ status: ${Number.isNaN(statusCode) ? "number" : String(statusCode)}; data: ${typeName}; statusText: string }`;
+	});
+	if (members.length === 1) return members[0];
+	return `(${members.join(" | ")})`;
+}
 const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
 function resolveOperationTypeNames(node, resolver, options = {}) {
 	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
@@ -506,26 +449,24 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 * shared default naming so every plugin groups output consistently:
 *
 * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
 *
 * A user-provided `group.name` always wins over the default namer, so callers stay in
 * control of their output folders. Returns `null` when grouping is disabled, matching the
 * per-plugin convention.
 *
 * @param group - The user-supplied group option, or `undefined` to disable grouping.
-* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
 *
 * @example
 * ```ts
-* createGroupConfig(group, { suffix: 'Controller' }) // plugin-ts, plugin-client, …
-* createGroupConfig(group, { suffix: 'Requests' })   // plugin-cypress, plugin-mcp
+* createGroupConfig(group) // shared across every plugin
 * ```
 */
-function createGroupConfig(group, options) {
+function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return `${camelCase(ctx.group)}${options.suffix}`;
+		return camelCase(ctx.group);
 	};
 	return {
 		...group,
@@ -551,43 +492,52 @@ const callPrinter = functionPrinter({ mode: "call" });
 function isGroup(spec) {
 	return "children" in spec;
 }
-function createType(type) {
-	return type ? ast.createParamsType({
-		variant: "reference",
-		name: type
-	}) : null;
+function groupEntries(group) {
+	return Object.entries(group.children).filter(([, child]) => child != null);
+}
+/**
+* Assembles a destructured group parameter from a binding pattern and an optional
+* type literal. Built directly because `createFunctionParameter({ properties })`
+* requires every member to carry a type, while these groups also hold untyped,
+* value-only call entries.
+*/
+function createGroupParam(elements, members, default_) {
+	return {
+		kind: "FunctionParameter",
+		name: ast.factory.createObjectBindingPattern({ elements }),
+		type: members.length ? ast.factory.createTypeLiteral({ members }) : void 0,
+		default: default_,
+		optional: false
+	};
 }
 function createDeclarationLeaf(name, spec) {
-	if (spec.default !== void 0) return ast.createFunctionParameter({
+	if (spec.default !== void 0) return ast.factory.createFunctionParameter({
 		name,
-		type: createType(spec.type) ?? void 0,
+		type: spec.type,
 		default: spec.default,
 		rest: spec.mode === "inlineSpread"
 	});
-	return ast.createFunctionParameter({
+	return ast.factory.createFunctionParameter({
 		name,
-		type: createType(spec.type) ?? void 0,
+		type: spec.type,
 		optional: !!spec.optional,
 		rest: spec.mode === "inlineSpread"
 	});
 }
 function createDeclarationParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		default: spec.default,
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => createDeclarationLeaf(childName, child))
-	});
+	if (isGroup(spec)) {
+		const entries = groupEntries(spec);
+		return createGroupParam(entries.map(([childName]) => ({ name: childName })), entries.filter(([, child]) => child.type).map(([childName, child]) => ({
+			name: childName,
+			type: child.type,
+			optional: !!child.optional || child.default !== void 0
+		})), spec.default);
+	}
 	return createDeclarationLeaf(name, spec);
 }
 function createCallParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => ast.createFunctionParameter({
-			name: child?.mode === "inlineSpread" ? spec.mode === "inlineSpread" ? child.value ?? childName : `...${child.value ?? childName}` : child?.value ? `${childName}: ${child.value}` : childName,
-			rest: spec.mode === "inlineSpread" && child?.mode === "inlineSpread"
-		}))
-	});
-	return ast.createFunctionParameter({
+	if (isGroup(spec)) return createGroupParam(groupEntries(spec).map(([childName, child]) => ({ name: child.mode === "inlineSpread" ? spec.mode === "inlineSpread" ? child.value ?? childName : `...${child.value ?? childName}` : child.value ? `${childName}: ${child.value}` : childName })), []);
+	return ast.factory.createFunctionParameter({
 		name: spec.value ?? name,
 		rest: spec.mode === "inlineSpread"
 	});
@@ -600,23 +550,159 @@ function createFunctionParams(params) {
 	const entries = Object.entries(params).filter(([, spec]) => spec != null);
 	return {
 		toConstructor() {
-			return declarationPrinter$4.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createDeclarationParam(name, spec)) })) ?? "";
+			return declarationPrinter$4.print(ast.factory.createFunctionParameters({ params: entries.map(([name, spec]) => createDeclarationParam(name, spec)) })) ?? "";
 		},
 		toCall() {
-			return callPrinter.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createCallParam(name, spec)) })) ?? "";
+			return callPrinter.print(ast.factory.createFunctionParameters({ params: entries.map(([name, spec]) => createCallParam(name, spec)) })) ?? "";
 		}
 	};
 }
 //#endregion
+//#region src/utils.ts
+/**
+* Returns `true` when any direction of the parser uses Zod (used for dependency checks).
+*/
+function isParserEnabled(parser) {
+	if (!parser) return false;
+	if (parser === "zod") return true;
+	return !!(parser.request || parser.response);
+}
+/**
+* Returns `'zod'` when request body parsing is enabled, `null` otherwise.
+* The string shorthand `'zod'` also enables request body parsing (existing behavior).
+*/
+function resolveRequestParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise.
+* Only the object form `{ request: 'zod' }` enables query-params parsing.
+* The string shorthand `'zod'` does not, preserving its existing behavior.
+*/
+function resolveQueryParamsParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when response-direction parsing is enabled, `null` otherwise.
+* `parser: 'zod'` (string shorthand) maps to response parsing and returns `'zod'`.
+*/
+function resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.response ?? null;
+}
+/**
+* Builds HTTP headers array for a client request.
+* Includes Content-Type (if not default) and spreads header parameters if present.
+*/
+function buildHeaders(contentType, hasHeaderParams) {
+	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, hasHeaderParams ? "...headers" : null].filter(Boolean);
+}
+/**
+* Returns the generic type arguments — response, error, and request body — for a generated
+* client call.
+*
+* When `dataReturnType` is `'full'`, the response generic widens to a union of all documented
+* status types. When `parser` is `'zod'` and a request body schema exists, the request type
+* uses `z.output<typeof schema>` to reflect post-transform types (e.g. date coercion).
+*/
+function buildGenerics(node, tsResolver, options = {}) {
+	const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = options.dataReturnType === "full" ? allStatusNames.length > 0 ? allStatusNames.join(" | ") : tsResolver.resolveResponseName(node) : successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
+	const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const zodRequestName = options.parser === "zod" && options.zodResolver && node.requestBody?.content?.[0]?.schema ? options.zodResolver.resolveDataName?.(node) ?? null : null;
+	return [
+		responseName,
+		TError,
+		zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || "unknown"
+	].filter(Boolean);
+}
+/**
+* Builds the parameters object for a class-based client method.
+* Includes URL, method, base URL, headers, and request/response data.
+*/
+function buildClassClientParams({ node, url, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers, zodQueryParamsName }) {
+	const { query: queryParams } = getOperationParameters(node);
+	const queryParamsName = queryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, queryParams[0]) : null;
+	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
+	const responseType = getResponseType(node);
+	return createFunctionParams({ config: {
+		mode: "object",
+		children: {
+			requestConfig: { mode: "inlineSpread" },
+			method: { value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : "") },
+			url: { value: url },
+			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : null,
+			params: queryParamsName ? zodQueryParamsName ? { value: "requestParams" } : {} : null,
+			data: requestName ? { value: isMultipleContentTypes && hasFormData ? "contentType === 'multipart/form-data' ? formData as FormData : requestData" : isFormData ? "formData as FormData" : "requestData" } : null,
+			contentType: isMultipleContentTypes ? {} : null,
+			responseType: responseType ? { value: JSON.stringify(responseType) } : null,
+			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : null
+		}
+	} });
+}
+/**
+* Builds the request data parsing line for client methods.
+* Applies Zod validation when `parser.request === 'zod'`, otherwise assigns data directly.
+*/
+function buildRequestDataLine({ parser, node, zodResolver }) {
+	const requestParser = resolveRequestParser(parser);
+	const zodRequestName = zodResolver && requestParser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
+	if (requestParser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
+	if (node.requestBody?.content?.[0]?.schema) return "const requestData = data";
+	return "";
+}
+/**
+* Builds the query parameters parsing line for client methods.
+* Returns an empty string when no query params exist or query-params parsing is not enabled.
+* Only the object form `parser: { request: 'zod' }` triggers this. `parser: 'zod'` does not.
+*/
+function buildQueryParamsLine({ parser, node, zodResolver }) {
+	if (resolveQueryParamsParser(parser) !== "zod" || !zodResolver) return "";
+	const { query: queryParams } = getOperationParameters(node);
+	if (queryParams.length === 0) return "";
+	const zodQueryParamsName = zodResolver.resolveQueryParamsName?.(node, queryParams[0]);
+	if (!zodQueryParamsName) return "";
+	return `const requestParams = ${zodQueryParamsName}.parse(params)`;
+}
+/**
+* Builds the form data conversion line for file upload requests.
+* Returns empty string if not applicable.
+*/
+function buildFormDataLine(isFormData, hasRequest) {
+	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+}
+/**
+* Builds the return statement for a client method.
+* When `dataReturnType` is `'full'`, casts the response to the status-discriminated union type.
+* When `parser.response` is `'zod'`, pipes the response body through the Zod schema before returning.
+*/
+function buildReturnStatement({ dataReturnType, parser, node, zodResolver, tsResolver }) {
+	const responseParser = resolveResponseParser(parser);
+	const zodResponseName = zodResolver && responseParser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
+	if (dataReturnType === "full" && tsResolver) {
+		const unionType = buildStatusUnionType(node, tsResolver);
+		if (responseParser === "zod" && zodResponseName) return `return {...res, data: ${zodResponseName}.parse(res.data)} as ${unionType}`;
+		return `return res as ${unionType}`;
+	}
+	if (dataReturnType === "data" && responseParser === "zod" && zodResponseName) return `return ${zodResponseName}.parse(res.data)`;
+	return "return res.data";
+}
+//#endregion
 //#region src/components/Url.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
-	const urlNode = {
+	return createOperationParams({
 		...node,
 		parameters: node.parameters.filter((p) => p.in === "path"),
 		requestBody: void 0
-	};
-	return ast.createOperationParams(urlNode, {
+	}, {
 		paramsType: paramsType === "object" ? "object" : "inline",
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -625,7 +711,6 @@ function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, ts
 }
 function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const path = new URLPath(node.path);
 	const paramsNode = buildUrlParamsNode({
 		paramsType,
 		paramsCasing,
@@ -650,7 +735,7 @@ function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsTyp
 				pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && /* @__PURE__ */ jsx("br", {}),
 				/* @__PURE__ */ jsx(Const, {
 					name: "res",
-					children: `{ method: '${node.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`
+					children: `{ method: '${node.method.toUpperCase()}', url: ${Url$1.toTemplateString(node.path, { prefix: baseURL })} as const }`
 				}),
 				/* @__PURE__ */ jsx("br", {}),
 				"return res"
@@ -662,24 +747,20 @@ function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsTyp
 //#region src/components/Client.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 function buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [...isConfigurable ? [ast.createFunctionParameter({
+		extraParams: [...isConfigurable ? [ast.factory.createFunctionParameter({
 			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})] : []]
 	});
 }
 function Client({ name, isExportable = true, isIndexable = true, returnType, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, node, tsResolver, zodResolver, urlName, children, isConfigurable = true }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const path = new URLPath(node.path);
 	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
 	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
 	const responseType = getResponseType(node);
@@ -693,16 +774,22 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const queryParamsName = originalQueryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, originalQueryParams[0]) : null;
 	const headerParamsName = originalHeaderParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, originalHeaderParams[0]) : null;
-	const zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
-	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
+	const requestParser = resolveRequestParser(parser);
+	const responseParser = resolveResponseParser(parser);
+	const zodResponseName = zodResolver && responseParser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
+	const zodRequestName = zodResolver && requestParser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
+	const queryParamsParser = resolveQueryParamsParser(parser);
+	const zodQueryParamsName = zodResolver && queryParamsParser === "zod" && originalQueryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, originalQueryParams[0]) : null;
 	const errorNames = node.responses.filter((r) => {
 		return Number.parseInt(r.statusCode, 10) >= 400;
 	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
 	const headers = [!isMultipleContentTypes && contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, headerParamsName ? headerParamsMapping ? "...mappedHeaders" : "...headers" : null].filter(Boolean);
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
 	const generics = [
-		responseName,
-		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
-		requestName || "unknown"
+		dataReturnType === "full" ? allStatusNames.length > 0 ? allStatusNames.join(" | ") : responseName : responseName,
+		TError,
+		parser === "zod" && zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || "unknown"
 	].filter(Boolean);
 	const paramsNode = buildClientParamsNode({
 		paramsType,
@@ -724,22 +811,23 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 	const clientParams = createFunctionParams({ config: {
 		mode: "object",
 		children: {
-			method: { value: JSON.stringify(node.method.toUpperCase()) },
-			url: { value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : path.template },
+			method: { value: stringify(node.method.toUpperCase()) },
+			url: { value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : Url$1.toTemplateString(node.path) },
 			baseURL: baseURL && !urlName ? { value: `\`${baseURL}\`` } : null,
-			params: queryParamsName ? queryParamsMapping ? { value: "mappedParams" } : {} : null,
+			params: queryParamsName ? zodQueryParamsName ? { value: "requestParams" } : queryParamsMapping ? { value: "mappedParams" } : {} : null,
 			data: requestName ? { value: isMultipleContentTypes && hasFormData ? "contentType === 'multipart/form-data' ? formData as FormData : requestData" : isFormData ? "formData as FormData" : "requestData" } : null,
 			contentType: isConfigurable && isMultipleContentTypes ? {} : null,
-			responseType: responseType ? { value: JSON.stringify(responseType) } : null,
+			responseType: responseType ? { value: stringify(responseType) } : null,
 			requestConfig: isConfigurable ? { mode: "inlineSpread" } : null,
 			headers: headers.length ? { value: isConfigurable ? `{ ${headers.join(", ")}, ...requestConfig.headers }` : `{ ${headers.join(", ")} }` } : null
 		}
 	} });
+	const statusUnionType = dataReturnType === "full" ? buildStatusUnionType(node, tsResolver) : null;
 	const childrenElement = children ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
-		dataReturnType === "full" && parser === "zod" && zodResponseName && `return {...res, data: ${zodResponseName}.parse(res.data)}`,
-		dataReturnType === "data" && parser === "zod" && zodResponseName && `return ${zodResponseName}.parse(res.data)`,
-		dataReturnType === "full" && parser !== "zod" && "return res",
-		dataReturnType === "data" && parser !== "zod" && "return res.data"
+		dataReturnType === "full" && responseParser === "zod" && zodResponseName && statusUnionType && `return {...res, data: ${zodResponseName}.parse(res.data)} as ${statusUnionType}`,
+		dataReturnType === "full" && responseParser !== "zod" && statusUnionType && `return res as ${statusUnionType}`,
+		dataReturnType === "data" && responseParser === "zod" && zodResponseName && `return ${zodResponseName}.parse(res.data)`,
+		dataReturnType === "data" && responseParser !== "zod" && "return res.data"
 	] });
 	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -757,23 +845,14 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 			}) },
 			returnType,
 			children: [
-				isConfigurable ? `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = config` : "",
-				/* @__PURE__ */ jsx("br", {}),
+				isConfigurable ? `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = config` : "",
 				/* @__PURE__ */ jsx("br", {}),
 				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
-				pathParamsMapping && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx("br", {})] }),
-				queryParamsMapping && queryParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [
-					`const mappedParams = params ? { ${Object.entries(queryParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`).join(", ")} } : undefined`,
-					/* @__PURE__ */ jsx("br", {}),
-					/* @__PURE__ */ jsx("br", {})
-				] }),
-				headerParamsMapping && headerParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [
-					`const mappedHeaders = headers ? { ${Object.entries(headerParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`).join(", ")} } : undefined`,
-					/* @__PURE__ */ jsx("br", {}),
-					/* @__PURE__ */ jsx("br", {})
-				] }),
-				parser === "zod" && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && "const requestData = data",
-				/* @__PURE__ */ jsx("br", {}),
+				pathParamsMapping && /* @__PURE__ */ jsx("br", {}),
+				queryParamsMapping && queryParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [`const mappedParams = params ? { ${Object.entries(queryParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`).join(", ")} } : undefined`, /* @__PURE__ */ jsx("br", {})] }),
+				headerParamsMapping && headerParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [`const mappedHeaders = headers ? { ${Object.entries(headerParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`).join(", ")} } : undefined`, /* @__PURE__ */ jsx("br", {})] }),
+				requestParser === "zod" && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && "const requestData = data",
+				zodQueryParamsName && `const requestParams = ${zodQueryParamsName}.parse(params)`,
 				(isFormData || isMultipleContentTypes && hasFormData) && requestName && "const formData = buildFormData(requestData)",
 				/* @__PURE__ */ jsx("br", {}),
 				isConfigurable ? `const res = await request<${generics.join(", ")}>(${clientParams.toCall()})` : `const res = await client<${generics.join(", ")}>(${clientParams.toCall()})`,
@@ -784,93 +863,20 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 	})] });
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Builds HTTP headers array for a client request.
-* Includes Content-Type (if not default) and spreads header parameters if present.
-*/
-function buildHeaders(contentType, hasHeaderParams) {
-	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, hasHeaderParams ? "...headers" : null].filter(Boolean);
-}
-/**
-* Builds TypeScript generic parameters for a client method.
-* Includes response type, error type, and optional request type.
-*/
-function buildGenerics(node, tsResolver) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
-	const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	return [
-		responseName,
-		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
-		requestName || "unknown"
-	].filter(Boolean);
-}
-/**
-* Builds the parameters object for a class-based client method.
-* Includes URL, method, base URL, headers, and request/response data.
-*/
-function buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers }) {
-	const { query: queryParams } = getOperationParameters(node);
-	const queryParamsName = queryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, queryParams[0]) : null;
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
-	const responseType = getResponseType(node);
-	return createFunctionParams({ config: {
-		mode: "object",
-		children: {
-			requestConfig: { mode: "inlineSpread" },
-			method: { value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : "") },
-			url: { value: path.template },
-			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : null,
-			params: queryParamsName ? {} : null,
-			data: requestName ? { value: isMultipleContentTypes && hasFormData ? "contentType === 'multipart/form-data' ? formData as FormData : requestData" : isFormData ? "formData as FormData" : "requestData" } : null,
-			contentType: isMultipleContentTypes ? {} : null,
-			responseType: responseType ? { value: JSON.stringify(responseType) } : null,
-			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : null
-		}
-	} });
-}
-/**
-* Builds the request data parsing line for client methods.
-* Applies Zod validation if configured, otherwise uses data directly.
-*/
-function buildRequestDataLine({ parser, node, zodResolver }) {
-	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
-	if (parser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
-	if (node.requestBody?.content?.[0]?.schema) return "const requestData = data";
-	return "";
-}
-/**
-* Builds the form data conversion line for file upload requests.
-* Returns empty string if not applicable.
-*/
-function buildFormDataLine(isFormData, hasRequest) {
-	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
-}
-/**
-* Builds the return statement for a client method.
-* Applies Zod validation to response data if configured, otherwise returns raw response.
-*/
-function buildReturnStatement({ dataReturnType, parser, node, zodResolver }) {
-	const zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
-	if (dataReturnType === "full" && parser === "zod" && zodResponseName) return `return {...res, data: ${zodResponseName}.parse(res.data)}`;
-	if (dataReturnType === "data" && parser === "zod" && zodResponseName) return `return ${zodResponseName}.parse(res.data)`;
-	if (dataReturnType === "full" && parser !== "zod") return "return res";
-	return "return res.data";
-}
-//#endregion
 //#region src/components/ClassClient.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
 	if (!ast.isHttpOperationNode(node)) return "";
-	const path = new URLPath(node.path, { casing: paramsCasing });
 	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
 	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
 	const { header: headerParams } = getOperationParameters(node);
 	const headerParamsName = headerParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, headerParams[0]) : null;
 	const headers = isMultipleContentTypes ? headerParamsName ? ["...headers"] : [] : buildHeaders(contentType, !!headerParamsName);
-	const generics = buildGenerics(node, tsResolver);
+	const generics = buildGenerics(node, tsResolver, {
+		dataReturnType,
+		zodResolver,
+		parser
+	});
 	const paramsNode = buildClientParamsNode({
 		paramsType,
 		paramsCasing,
@@ -880,15 +886,18 @@ function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataRe
 		isConfigurable: true
 	});
 	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	const { query: queryParams } = getOperationParameters(node);
+	const zodQueryParamsName = zodResolver && resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null;
 	const clientParams = buildClassClientParams({
 		node,
-		path,
+		url: Url$1.toTemplateString(node.path, { casing: paramsCasing }),
 		baseURL,
 		tsResolver,
 		isFormData,
 		isMultipleContentTypes,
 		hasFormData,
-		headers
+		headers,
+		zodQueryParamsName
 	});
 	const jsdoc = buildJSDoc(buildOperationComments(node, {
 		link: "urlPath",
@@ -900,17 +909,24 @@ function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataRe
 		node,
 		zodResolver
 	});
+	const queryParamsLine = buildQueryParamsLine({
+		parser,
+		node,
+		zodResolver
+	});
 	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
 	const returnStatement = buildReturnStatement({
 		dataReturnType,
 		parser,
 		node,
-		zodResolver
+		zodResolver,
+		tsResolver
 	});
 	return `${jsdoc}async ${name}(${paramsSignature}) {\n${[
-		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
+		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
 		"",
 		requestDataLine,
+		queryParamsLine,
 		formDataLine,
 		`const res = await request<${generics.join(", ")}>(${clientParams.toCall()})`,
 		returnStatement
@@ -968,8 +984,13 @@ function resolveTypeImportNames$1(node, tsResolver) {
 	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
 }
 __name(resolveTypeImportNames$1, "resolveTypeImportNames");
-function resolveZodImportNames$1(node, zodResolver) {
-	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((n) => Boolean(n));
+function resolveZodImportNames$1(node, zodResolver, parser) {
+	const { query: queryParams } = getOperationParameters(node);
+	return [
+		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+	].filter((n) => Boolean(n));
 }
 __name(resolveZodImportNames$1, "resolveZodImportNames");
 /**
@@ -979,7 +1000,7 @@ __name(resolveZodImportNames$1, "resolveZodImportNames");
 */
 const classClientGenerator = defineGenerator({
 	name: "classClient",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operations(nodes, ctx) {
 		const { config, driver, resolver, root } = ctx;
 		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = ctx.options;
@@ -988,7 +1009,7 @@ const classClientGenerator = defineGenerator({
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
 		const tsPluginOptions = pluginTs.options;
-		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
 		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		function buildOperationData(node) {
 			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
@@ -1013,7 +1034,7 @@ const classClientGenerator = defineGenerator({
 		const controllers = nodes.reduce((acc, operationNode) => {
 			if (!ast.isHttpOperationNode(operationNode)) return acc;
 			const tag = operationNode.tags[0];
-			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveGroupName("Client");
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveClassName("Client");
 			if (!tag && !group) {
 				const name = resolver.resolveClassName("ApiClient");
 				const file = resolver.resolveFile({
@@ -1080,7 +1101,7 @@ const classClientGenerator = defineGenerator({
 			const zodFilesByPath = /* @__PURE__ */ new Map();
 			ops.forEach((op) => {
 				if (!op.zodFile || !zodResolver) return;
-				const names = resolveZodImportNames$1(op.node, zodResolver);
+				const names = resolveZodImportNames$1(op.node, zodResolver, parser);
 				if (!zodImportsByFile.has(op.zodFile.path)) zodImportsByFile.set(op.zodFile.path, /* @__PURE__ */ new Set());
 				const imports = zodImportsByFile.get(op.zodFile.path);
 				names.forEach((n) => {
@@ -1095,7 +1116,7 @@ const classClientGenerator = defineGenerator({
 		}
 		const files = controllers.map(({ name, file, operations: ops }) => {
 			const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
-			const { zodImportsByFile, zodFilesByPath } = parser === "zod" ? collectZodImports(ops) : {
+			const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser) ? collectZodImports(ops) : {
 				zodImportsByFile: /* @__PURE__ */ new Map(),
 				zodFilesByPath: /* @__PURE__ */ new Map()
 			};
@@ -1166,6 +1187,11 @@ const classClientGenerator = defineGenerator({
 						root: file.path,
 						path: path.resolve(root, ".kubb/config.ts")
 					}),
+					parser === "zod" && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
+						name: ["z"],
+						path: "zod",
+						isTypeOnly: true
+					}),
 					Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
 						const typeFile = typeFilesByPath.get(filePath);
 						if (!typeFile) return null;
@@ -1178,7 +1204,7 @@ const classClientGenerator = defineGenerator({
 							isTypeOnly: true
 						}, filePath);
 					}),
-					parser === "zod" && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
+					isParserEnabled(parser) && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
 						const zodFile = zodFilesByPath.get(filePath);
 						if (!zodFile) return null;
 						const importNames = Array.from(importSet).filter(Boolean);
@@ -1269,7 +1295,7 @@ const classClientGenerator = defineGenerator({
 */
 const clientGenerator = defineGenerator({
 	name: "client",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, driver, resolver, root } = ctx;
@@ -1278,10 +1304,16 @@ const clientGenerator = defineGenerator({
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
 		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing });
-		const importedZodNames = zodResolver && parser === "zod" ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((name) => Boolean(name)) : [];
+		const { query: queryParams } = getOperationParameters(node);
+		const importedZodNames = zodResolver ? [
+			resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+			resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+			resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+		].filter((name) => Boolean(name)) : [];
+		const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) ?? null : null;
 		const meta = {
 			name: resolver.resolveName(node.operationId),
 			urlName: resolver.resolveUrlName(node),
@@ -1353,6 +1385,11 @@ const clientGenerator = defineGenerator({
 					root: meta.file.path,
 					path: path.resolve(root, ".kubb/config.ts")
 				}),
+				zodRequestName && /* @__PURE__ */ jsx(File.Import, {
+					name: ["z"],
+					path: "zod",
+					isTypeOnly: true
+				}),
 				meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
 					name: importedZodNames,
 					root: meta.file.path,
@@ -1402,7 +1439,7 @@ const clientGenerator = defineGenerator({
 */
 const groupedClientGenerator = defineGenerator({
 	name: "groupedClient",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operations(nodes, ctx) {
 		const { config, resolver, root } = ctx;
 		const { output, group } = ctx.options;
@@ -1485,29 +1522,7 @@ const groupedClientGenerator = defineGenerator({
 	}
 });
 //#endregion
-//#region src/components/Operations.tsx
-function Operations({ name, nodes }) {
-	const operationsObject = {};
-	nodes.forEach((node) => {
-		if (!ast.isHttpOperationNode(node)) return;
-		operationsObject[node.operationId] = {
-			path: new URLPath(node.path).URL,
-			method: node.method.toLowerCase()
-		};
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Const, {
-			name,
-			export: true,
-			children: JSON.stringify(operationsObject, void 0, 2)
-		})
-	});
-}
-//#endregion
-//#region src/generators/operationsGenerator.tsx
+//#region src/generators/operationsGenerator.ts
 /**
 * Generates an `operations.ts` file that re-exports every operation grouped
 * by HTTP method. Enabled when `pluginClient({ operations: true })`. Useful
@@ -1516,7 +1531,6 @@ function Operations({ name, nodes }) {
 */
 const operationsGenerator = defineGenerator({
 	name: "client",
-	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
 		const { config, resolver, root } = ctx;
 		const { output, group } = ctx.options;
@@ -1529,7 +1543,15 @@ const operationsGenerator = defineGenerator({
 			output,
 			group: group ?? void 0
 		});
-		return /* @__PURE__ */ jsx(File, {
+		const operationsObject = {};
+		for (const node of nodes) {
+			if (!ast.isHttpOperationNode(node)) continue;
+			operationsObject[node.operationId] = {
+				path: Url$1.toPath(node.path),
+				method: node.method.toLowerCase()
+			};
+		}
+		return [ast.factory.createFile({
 			baseName: file.baseName,
 			path: file.path,
 			meta: file.meta,
@@ -1549,11 +1571,17 @@ const operationsGenerator = defineGenerator({
 					baseName: file.baseName
 				}
 			}),
-			children: /* @__PURE__ */ jsx(Operations, {
+			sources: [ast.factory.createSource({
 				name,
-				nodes: nodes.filter(ast.isHttpOperationNode)
-			})
-		});
+				isExportable: true,
+				isIndexable: true,
+				nodes: [ast.factory.createConst({
+					name,
+					export: true,
+					nodes: [ast.factory.createText(JSON.stringify(operationsObject, void 0, 2))]
+				})]
+			})]
+		})];
 	}
 });
 //#endregion
@@ -1561,13 +1589,16 @@ const operationsGenerator = defineGenerator({
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
 	if (!ast.isHttpOperationNode(node)) return "";
-	const path = new URLPath(node.path, { casing: paramsCasing });
 	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
 	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
 	const { header: headerParams } = getOperationParameters(node);
 	const headerParamsName = headerParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, headerParams[0]) : null;
 	const headers = isMultipleContentTypes ? headerParamsName ? ["...headers"] : [] : buildHeaders(contentType, !!headerParamsName);
-	const generics = buildGenerics(node, tsResolver);
+	const generics = buildGenerics(node, tsResolver, {
+		dataReturnType,
+		zodResolver,
+		parser
+	});
 	const paramsNode = buildClientParamsNode({
 		paramsType,
 		paramsCasing,
@@ -1577,15 +1608,18 @@ function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataRetu
 		isConfigurable: true
 	});
 	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const { query: queryParams } = getOperationParameters(node);
+	const zodQueryParamsName = zodResolver && resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null;
 	const clientParams = buildClassClientParams({
 		node,
-		path,
+		url: Url$1.toTemplateString(node.path, { casing: paramsCasing }),
 		baseURL,
 		tsResolver,
 		isFormData,
 		isMultipleContentTypes,
 		hasFormData,
-		headers
+		headers,
+		zodQueryParamsName
 	});
 	const jsdoc = buildJSDoc(buildOperationComments(node, {
 		link: "urlPath",
@@ -1597,17 +1631,24 @@ function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataRetu
 		node,
 		zodResolver
 	});
+	const queryParamsLine = buildQueryParamsLine({
+		parser,
+		node,
+		zodResolver
+	});
 	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
 	const returnStatement = buildReturnStatement({
 		dataReturnType,
 		parser,
 		node,
-		zodResolver
+		zodResolver,
+		tsResolver
 	});
 	return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${[
-		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
+		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
 		"",
 		requestDataLine,
+		queryParamsLine,
 		formDataLine,
 		`const res = await request<${generics.join(", ")}>(${clientParams.toCall()})`,
 		returnStatement
@@ -1638,8 +1679,13 @@ function StaticClassClient({ name, isExportable = true, isIndexable = true, oper
 function resolveTypeImportNames(node, tsResolver) {
 	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
 }
-function resolveZodImportNames(node, zodResolver) {
-	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((n) => Boolean(n));
+function resolveZodImportNames(node, zodResolver, parser) {
+	const { query: queryParams } = getOperationParameters(node);
+	return [
+		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+	].filter((n) => Boolean(n));
 }
 /**
 * Built-in `operations` generator for `@kubb/plugin-client` when
@@ -1649,7 +1695,7 @@ function resolveZodImportNames(node, zodResolver) {
 */
 const staticClassClientGenerator = defineGenerator({
 	name: "staticClassClient",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operations(nodes, ctx) {
 		const { config, driver, resolver, root } = ctx;
 		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = ctx.options;
@@ -1658,7 +1704,7 @@ const staticClassClientGenerator = defineGenerator({
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
 		const tsPluginOptions = pluginTs.options;
-		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
 		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		function buildOperationData(node) {
 			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
@@ -1683,7 +1729,7 @@ const staticClassClientGenerator = defineGenerator({
 		const controllers = nodes.reduce((acc, operationNode) => {
 			if (!ast.isHttpOperationNode(operationNode)) return acc;
 			const tag = operationNode.tags[0];
-			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveGroupName("Client");
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveClassName("Client");
 			if (!tag && !group) {
 				const name = resolver.resolveClassName("ApiClient");
 				const file = resolver.resolveFile({
@@ -1748,7 +1794,7 @@ const staticClassClientGenerator = defineGenerator({
 			const zodFilesByPath = /* @__PURE__ */ new Map();
 			ops.forEach((op) => {
 				if (!op.zodFile || !zodResolver) return;
-				const names = resolveZodImportNames(op.node, zodResolver);
+				const names = resolveZodImportNames(op.node, zodResolver, parser);
 				if (!zodImportsByFile.has(op.zodFile.path)) zodImportsByFile.set(op.zodFile.path, /* @__PURE__ */ new Set());
 				const imports = zodImportsByFile.get(op.zodFile.path);
 				names.forEach((n) => {
@@ -1763,7 +1809,7 @@ const staticClassClientGenerator = defineGenerator({
 		}
 		return /* @__PURE__ */ jsx(Fragment, { children: controllers.map(({ name, file, operations: ops }) => {
 			const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
-			const { zodImportsByFile, zodFilesByPath } = parser === "zod" ? collectZodImports(ops) : {
+			const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser) ? collectZodImports(ops) : {
 				zodImportsByFile: /* @__PURE__ */ new Map(),
 				zodFilesByPath: /* @__PURE__ */ new Map()
 			};
@@ -1834,6 +1880,11 @@ const staticClassClientGenerator = defineGenerator({
 						root: file.path,
 						path: path.resolve(root, ".kubb/config.ts")
 					}),
+					parser === "zod" && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
+						name: ["z"],
+						path: "zod",
+						isTypeOnly: true
+					}),
 					Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
 						const typeFile = typeFilesByPath.get(filePath);
 						if (!typeFile) return null;
@@ -1846,7 +1897,7 @@ const staticClassClientGenerator = defineGenerator({
 							isTypeOnly: true
 						}, filePath);
 					}),
-					parser === "zod" && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
+					isParserEnabled(parser) && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
 						const zodFile = zodFilesByPath.get(filePath);
 						if (!zodFile) return null;
 						const importNames = Array.from(importSet).filter(Boolean);
@@ -1885,6 +1936,7 @@ const staticClassClientGenerator = defineGenerator({
 *
 * resolverClient.default('list pets', 'function') // 'listPets'
 * resolverClient.resolveClassName('pet')          // 'Pet'
+* resolverClient.resolveGroupName('pet')          // 'PetClient'
 * resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
 * ```
 */
@@ -1892,8 +1944,8 @@ const resolverClient = defineResolver(() => ({
 	name: "default",
 	pluginName: "plugin-client",
 	default(name, type) {
-		const resolved = camelCase(name, { isFile: type === "file" });
-		return type === "file" ? resolved : ensureValidVarName(resolved);
+		if (type === "file") return toFilePath(name);
+		return ensureValidVarName(camelCase(name));
 	},
 	resolveName(name) {
 		return this.default(name, "function");
@@ -1905,7 +1957,7 @@ const resolverClient = defineResolver(() => ({
 		return ensureValidVarName(pascalCase(name));
 	},
 	resolveGroupName(name) {
-		return ensureValidVarName(pascalCase(name));
+		return ensureValidVarName(pascalCase(`${name} Client`));
 	},
 	resolveClientPropertyName(name) {
 		return ensureValidVarName(camelCase(name));
@@ -1950,19 +2002,19 @@ const pluginClientName = "plugin-client";
 const pluginClient = definePlugin((options) => {
 	const { output = {
 		path: "clients",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], urlType = false, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = options.sdk ? "class" : "function", parser = false, client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, transformer: userTransformer } = options;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], urlType = false, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = options.sdk ? "class" : "function", parser = false, client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, macros: userMacros } = options;
 	const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : void 0);
 	const selectedGenerators = options.generators ?? [
 		clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
 		group && clientType === "function" ? groupedClientGenerator : null,
 		operations ? operationsGenerator : null
 	].filter((x) => Boolean(x));
-	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginClientName,
 		options,
-		dependencies: [pluginTsName, parser === "zod" ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		dependencies: [pluginTsName, isParserEnabled(parser) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
 			const resolver = userResolver ? {
 				...resolverClient,
@@ -1989,7 +2041,7 @@ const pluginClient = definePlugin((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			for (const gen of selectedGenerators) ctx.addGenerator(gen);
 			const root = path.resolve(ctx.config.root, ctx.config.output.path);
 			if (!resolvedImportPath?.startsWith(".")) {
@@ -1997,21 +2049,21 @@ const pluginClient = definePlugin((options) => {
 				ctx.injectFile({
 					baseName: "client.ts",
 					path: path.resolve(root, ".kubb/client.ts"),
-					sources: [ast.createSource({
+					sources: [ast.factory.createSource({
 						name: "client",
-						nodes: isInlineSource ? [ast.createText(client === "fetch" ? source$1 : source)] : [],
+						nodes: isInlineSource ? [ast.factory.createText(client === "fetch" ? source$1 : source)] : [],
 						isExportable: true,
 						isIndexable: true
 					})],
-					exports: !isInlineSource && resolvedImportPath ? [ast.createExport({ path: resolvedImportPath })] : []
+					exports: !isInlineSource && resolvedImportPath ? [ast.factory.createExport({ path: resolvedImportPath })] : []
 				});
 			}
 			ctx.injectFile({
 				baseName: "config.ts",
 				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.createSource({
+				sources: [ast.factory.createSource({
 					name: "config",
-					nodes: [ast.createText(source$2)],
+					nodes: [ast.factory.createText(source$2)],
 					isExportable: false,
 					isIndexable: false
 				})]
@@ -2020,6 +2072,6 @@ const pluginClient = definePlugin((options) => {
 	};
 });
 //#endregion
-export { Client, classClientGenerator, clientGenerator, pluginClient as default, pluginClient, groupedClientGenerator, operationsGenerator, pluginClientName, resolverClient, staticClassClientGenerator };
+export { Client, classClientGenerator, clientGenerator, pluginClient as default, pluginClient, groupedClientGenerator, isParserEnabled, operationsGenerator, pluginClientName, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser, resolverClient, staticClassClientGenerator };
 
 //# sourceMappingURL=index.js.map