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

package/src/generators/operationsGenerator.ts

@@ -0,0 +1,47 @@
+import { Url } from '@internals/utils'
+import { ast, defineGenerator } from '@kubb/core'
+import type { PluginClient } from '../types'
+
+/**
+ * Generates an `operations.ts` file that re-exports every operation grouped
+ * by HTTP method. Enabled when `pluginClient({ operations: true })`. Useful
+ * for building meta-tooling on top of the generated client (route
+ * registries, API explorers).
+ */
+export const operationsGenerator = defineGenerator<PluginClient>({
+  name: 'client',
+  operations(nodes, ctx) {
+    const { config, resolver, root } = ctx
+    const { output, group } = ctx.options
+
+    const name = 'operations'
+    const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
+
+    const operationsObject: Record<string, { path: string; method: string }> = {}
+    for (const node of nodes) {
+      if (!ast.isHttpOperationNode(node)) continue
+      operationsObject[node.operationId] = {
+        path: Url.toPath(node.path),
+        method: node.method.toLowerCase(),
+      }
+    }
+
+    return [
+      ast.createFile({
+        baseName: file.baseName,
+        path: file.path,
+        meta: file.meta,
+        banner: resolver.resolveBanner(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } }),
+        footer: resolver.resolveFooter(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } }),
+        sources: [
+          ast.createSource({
+            name,
+            isExportable: true,
+            isIndexable: true,
+            nodes: [ast.createConst({ name, export: true, nodes: [ast.createText(JSON.stringify(operationsObject, undefined, 2))] })],
+          }),
+        ],
+      }),
+    ]
+  },
+})

package/src/generators/staticClassClientGenerator.tsx

@@ -1,14 +1,15 @@
 import path from 'node:path'
-import { operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
+import { getOperationParameters, operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
 import { camelCase } from '@internals/utils'
 import { ast, defineGenerator } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
 import { pluginTsName } from '@kubb/plugin-ts'
 import type { ResolverZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { StaticClassClient } from '../components/StaticClassClient'
 import type { PluginClient } from '../types'
+import { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from '../utils.ts'
 
 type OperationData = {
   node: ast.OperationNode
@@ -29,10 +30,12 @@ function resolveTypeImportNames(node: ast.OperationNode, tsResolver: ResolverTs)
   return resolveOperationTypeNames(node, tsResolver, { order: 'body-response-first' })
 }
 
-function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod): Array<string> {
+function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod, parser: PluginClient['resolvedOptions']['parser']): Array<string> {
+  const { query: queryParams } = getOperationParameters(node)
   const names: Array<string | null | undefined> = [
-    zodResolver.resolveResponseName?.(node),
-    node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+    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,
   ]
   return names.filter((n): n is string => Boolean(n))
 }
@@ -45,7 +48,7 @@ function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod
  */
 export const staticClassClientGenerator = defineGenerator<PluginClient>({
   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
@@ -56,7 +59,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
 
     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: ast.OperationNode): OperationData {
@@ -87,7 +90,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
     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')
@@ -144,7 +147,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
 
       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, new Set())
         }
@@ -162,8 +165,9 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
       <>
         {controllers.map(({ name, file, operations: ops }) => {
           const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
-          const { zodImportsByFile, zodFilesByPath } =
-            parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
+          const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser)
+            ? collectZodImports(ops)
+            : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
           const hasFormData = ops.some((op) => op.node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') ?? false)
 
           return (
@@ -196,6 +200,10 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
 
               {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(root, '.kubb/config.ts')} />}
 
+              {parser === 'zod' && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && (
+                <File.Import name={['z']} path="zod" isTypeOnly />
+              )}
+
               {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
                 const typeFile = typeFilesByPath.get(filePath)
                 if (!typeFile) return null
@@ -204,7 +212,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
                 return <File.Import key={filePath} name={importNames} root={file.path} path={typeFile.path} isTypeOnly />
               })}
 
-              {parser === 'zod' &&
+              {isParserEnabled(parser) &&
                 Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
                   const zodFile = zodFilesByPath.get(filePath)
                   if (!zodFile) return null

package/src/index.ts

@@ -2,8 +2,9 @@ export { Client } from './components/Client.tsx'
 export { classClientGenerator } from './generators/classClientGenerator.tsx'
 export { clientGenerator } from './generators/clientGenerator.tsx'
 export { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
-export { operationsGenerator } from './generators/operationsGenerator.tsx'
+export { operationsGenerator } from './generators/operationsGenerator.ts'
 export { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
 export { default, pluginClient, pluginClientName } from './plugin.ts'
 export { resolverClient } from './resolvers/resolverClient.ts'
+export { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from './utils.ts'
 export type { ClientImportPath, PluginClient, ResolverClient } from './types.ts'

package/src/plugin.ts

@@ -7,13 +7,14 @@ import { pluginZodName } from '@kubb/plugin-zod'
 import { classClientGenerator } from './generators/classClientGenerator.tsx'
 import { clientGenerator } from './generators/clientGenerator.tsx'
 import { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
-import { operationsGenerator } from './generators/operationsGenerator.tsx'
+import { operationsGenerator } from './generators/operationsGenerator.ts'
 import { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
 import { resolverClient } from './resolvers/resolverClient.ts'
 import { source as axiosClientSource } from './templates/clients/axios.source.ts'
 import { source as fetchClientSource } from './templates/clients/fetch.source.ts'
 import { source as configSource } from './templates/config.source.ts'
 import type { PluginClient } from './types.ts'
+import { isParserEnabled } from './utils.ts'
 
 /**
  * Canonical plugin name for `@kubb/plugin-client`. Used for driver lookups and
@@ -48,7 +49,7 @@ export const pluginClientName = 'plugin-client' satisfies PluginClient['name']
  */
 export const pluginClient = definePlugin<PluginClient>((options) => {
   const {
-    output = { path: 'clients', barrelType: 'named' },
+    output = { path: 'clients', barrel: { type: 'named' } },
     group,
     exclude = [],
     include,
@@ -80,12 +81,12 @@ export const pluginClient = definePlugin<PluginClient>((options) => {
       operations ? operationsGenerator : null,
     ].filter((x): x is NonNullable<typeof 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): dependency is string => Boolean(dependency)),
+    dependencies: [pluginTsName, isParserEnabled(parser) ? pluginZodName : null].filter((dependency): dependency is string => Boolean(dependency)),
     hooks: {
       'kubb:plugin:setup'(ctx) {
         const resolver = userResolver ? { ...resolverClient, ...userResolver } : resolverClient

package/src/resolvers/resolverClient.ts

@@ -1,4 +1,4 @@
-import { camelCase, ensureValidVarName, pascalCase } from '@internals/utils'
+import { camelCase, ensureValidVarName, pascalCase, toFilePath } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginClient } from '../types.ts'
 
@@ -13,6 +13,7 @@ import type { PluginClient } from '../types.ts'
  *
  * resolverClient.default('list pets', 'function') // 'listPets'
  * resolverClient.resolveClassName('pet')          // 'Pet'
+ * resolverClient.resolveGroupName('pet')          // 'PetClient'
  * resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
  * ```
  */
@@ -20,8 +21,8 @@ export const resolverClient = defineResolver<PluginClient>(() => ({
   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')
@@ -33,7 +34,7 @@ export const resolverClient = defineResolver<PluginClient>(() => ({
     return ensureValidVarName(pascalCase(name))
   },
   resolveGroupName(name) {
-    return ensureValidVarName(pascalCase(name))
+    return ensureValidVarName(pascalCase(`${name} Client`))
   },
   resolveClientPropertyName(name) {
     return ensureValidVarName(camelCase(name))

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 
 /**
  * The concrete resolver type for `@kubb/plugin-client`.
@@ -21,7 +21,12 @@ export type ResolverClient = Resolver & {
    */
   resolveClassName(this: ResolverClient, name: string): string
   /**
-   * Resolves the generated class name for tag-based client groups.
+   * Resolves the generated class name for tag-based client groups. The default
+   * appends a `Client` suffix (tag `pet` becomes `PetClient`) so the class never
+   * collides with the schema model of the same name in the barrel.
+   *
+   * @example Resolving tag-group class names
+   * `resolver.resolveGroupName('pet') // -> 'PetClient'`
    */
   resolveGroupName(this: ResolverClient, name: string): string
   /**
@@ -112,17 +117,13 @@ type ParamsTypeOptions =
       pathParamsType?: 'object' | 'inline'
     }
 
-export type Options = {
-  /**
-   * Where the generated client files are written and how they are exported.
-   *
-   * @default { path: 'clients', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
+/**
+ * Where the generated client files are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'clients', barrel: { type: 'named' } }
+ */
+export type Options = OutputOptions & {
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -157,7 +158,9 @@ export type Options = {
   /**
    * Shape of the value returned by each generated client function.
    * - `'data'` — only the response body.
-   * - `'full'` — the full response config (body, status, headers, request).
+   * - `'full'` — the full response as a discriminated union keyed by HTTP status code.
+   *   Each member is `{ status: N; data: StatusNType; statusText: string }`,
+   *   so narrowing on `res.status` also narrows `res.data` to the matching response type.
    *
    * @default 'data'
    */
@@ -170,14 +173,19 @@ export type Options = {
    */
   paramsCasing?: 'camelcase'
   /**
-   * Validator applied to response bodies before they are returned to the caller.
-   * - `false` (default) — no validation. The client has no runtime parser; the response is
-   *   returned as-is, cast to the generated TypeScript type.
-   * - `'zod'` — pipes responses through schemas from `@kubb/plugin-zod`.
+   * Validator applied to request and response bodies using schemas from `@kubb/plugin-zod`.
+   * - `false` (default): no validation. The response is returned as-is.
+   * - `'zod'`: validates response bodies only (backward-compatible shorthand).
+   * - `{ request?: 'zod'; response?: 'zod' }`: opt in per direction. `request` validates the
+   *   request body and query parameters before the call. `response` validates the response body.
    *
    * @default false
+   * @example Response only (shorthand)
+   * `parser: 'zod'`
+   * @example Both directions
+   * `parser: { request: 'zod', response: 'zod' }`
    */
-  parser?: false | 'zod'
+  parser?: false | 'zod' | { request?: 'zod'; response?: 'zod' }
   /**
    * Shape of the generated client.
    * - `'function'` — one standalone async function per operation.
@@ -206,8 +214,8 @@ export type Options = {
    *   sdk: { className: 'PetStoreSDK' },
    * })
    * // class PetStoreSDK {
-   * //   readonly petController: petController
-   * //   readonly storeController: storeController
+   * //   readonly petClient: PetClient
+   * //   readonly storeClient: StoreClient
    * //   constructor(config = {}) { ... }
    * // }
    * ```

package/src/utils.ts

@@ -1,11 +1,53 @@
-import { getOperationParameters, getResponseType, resolveSuccessNames } from '@internals/shared'
-import type { URLPath } from '@internals/utils'
+import { buildStatusUnionType, getOperationParameters, getResponseType, resolveSuccessNames } from '@internals/shared'
 import { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
 import type { ResolverZod } from '@kubb/plugin-zod'
 import { createFunctionParams } from './functionParams.ts'
 import type { PluginClient } from './types.ts'
 
+type ParserOption = PluginClient['resolvedOptions']['parser']
+
+/**
+ * Returns `true` when any direction of the parser uses Zod (used for dependency checks).
+ */
+export function isParserEnabled(parser: ParserOption | undefined | false): boolean {
+  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).
+ */
+export function resolveRequestParser(parser: ParserOption | undefined | false): 'zod' | null {
+  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.
+ */
+export function resolveQueryParamsParser(parser: ParserOption | undefined | false): 'zod' | null {
+  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'`.
+ */
+export function resolveResponseParser(parser: ParserOption | undefined | false): 'zod' | null {
+  if (!parser) return null
+  if (parser === 'zod') return 'zod'
+  return parser.response ?? null
+}
+
+export { buildStatusUnionType }
+
 /**
  * Builds HTTP headers array for a client request.
  * Includes Content-Type (if not default) and spreads header parameters if present.
@@ -18,16 +60,42 @@ export function buildHeaders(contentType: string, hasHeaderParams: boolean): Arr
 }
 
 /**
- * Builds TypeScript generic parameters for a client method.
- * Includes response type, error type, and optional request type.
+ * 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).
  */
-export function buildGenerics(node: ast.OperationNode, tsResolver: ResolverTs): Array<string> {
+export function buildGenerics(
+  node: ast.OperationNode,
+  tsResolver: ResolverTs,
+  options: {
+    dataReturnType?: PluginClient['resolvedOptions']['dataReturnType']
+    zodResolver?: ResolverZod | null
+    parser?: PluginClient['resolvedOptions']['parser']
+  } = {},
+): Array<string> {
+  const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
   const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
+  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'}>`
-  return [responseName, TError, requestName || 'unknown'].filter(Boolean)
+
+  const zodRequestName =
+    options.parser === 'zod' && options.zodResolver && node.requestBody?.content?.[0]?.schema ? (options.zodResolver.resolveDataName?.(node) ?? null) : null
+
+  const requestGenericType = zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || 'unknown'
+
+  return [responseName, TError, requestGenericType].filter(Boolean)
 }
 
 /**
@@ -36,22 +104,24 @@ export function buildGenerics(node: ast.OperationNode, tsResolver: ResolverTs):
  */
 export function buildClassClientParams({
   node,
-  path,
+  url,
   baseURL,
   tsResolver,
   isFormData,
   isMultipleContentTypes,
   hasFormData,
   headers,
+  zodQueryParamsName,
 }: {
   node: ast.OperationNode
-  path: URLPath
+  url: string
   baseURL: string | null | undefined
   tsResolver: ResolverTs
   isFormData: boolean
   isMultipleContentTypes: boolean
   hasFormData: boolean
   headers: Array<string>
+  zodQueryParamsName?: string | null
 }) {
   const { query: queryParams } = getOperationParameters(node)
   const queryParamsName = queryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, queryParams[0]!) : null
@@ -69,14 +139,14 @@ export function buildClassClientParams({
           value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : ''),
         },
         url: {
-          value: path.template,
+          value: url,
         },
         baseURL: baseURL
           ? {
               value: JSON.stringify(baseURL),
             }
           : null,
-        params: queryParamsName ? {} : null,
+        params: queryParamsName ? (zodQueryParamsName ? { value: 'requestParams' } : {}) : null,
         data: requestName
           ? {
               value:
@@ -101,7 +171,7 @@ export function buildClassClientParams({
 
 /**
  * Builds the request data parsing line for client methods.
- * Applies Zod validation if configured, otherwise uses data directly.
+ * Applies Zod validation when `parser.request === 'zod'`, otherwise assigns data directly.
  */
 export function buildRequestDataLine({
   parser,
@@ -112,8 +182,9 @@ export function buildRequestDataLine({
   node: ast.OperationNode
   zodResolver?: ResolverZod | null
 }): string {
-  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null
-  if (parser === 'zod' && zodRequestName) {
+  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) {
@@ -122,6 +193,28 @@ export function buildRequestDataLine({
   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.
+ */
+export function buildQueryParamsLine({
+  parser,
+  node,
+  zodResolver,
+}: {
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  node: ast.OperationNode
+  zodResolver?: ResolverZod | null
+}): string {
+  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.
@@ -132,28 +225,35 @@ export function buildFormDataLine(isFormData: boolean, hasRequest: boolean): str
 
 /**
  * Builds the return statement for a client method.
- * Applies Zod validation to response data if configured, otherwise returns raw response.
+ * 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.
  */
 export function buildReturnStatement({
   dataReturnType,
   parser,
   node,
   zodResolver,
+  tsResolver,
 }: {
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   node: ast.OperationNode
   zodResolver?: ResolverZod | null
+  tsResolver?: ResolverTs | null
 }): string {
-  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : null
-  if (dataReturnType === 'full' && parser === 'zod' && zodResponseName) {
-    return `return {...res, data: ${zodResponseName}.parse(res.data)}`
+  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' && parser === 'zod' && zodResponseName) {
+
+  if (dataReturnType === 'data' && responseParser === 'zod' && zodResponseName) {
     return `return ${zodResponseName}.parse(res.data)`
   }
-  if (dataReturnType === 'full' && parser !== 'zod') {
-    return 'return res'
-  }
   return 'return res.data'
 }