@kubb/plugin-client 5.0.0-alpha.29 → 5.0.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.0.0-alpha.29",
+  "version": "5.0.0-alpha.30",
   "description": "API client generator plugin for Kubb, creating type-safe HTTP clients (Axios, Fetch) from OpenAPI specifications for making API requests.",
   "keywords": [
     "api-client",
@@ -96,10 +96,10 @@
   "dependencies": {
     "@kubb/fabric-core": "0.15.1",
     "@kubb/react-fabric": "0.15.1",
-    "@kubb/ast": "5.0.0-alpha.29",
-    "@kubb/core": "5.0.0-alpha.29",
-    "@kubb/plugin-ts": "5.0.0-alpha.29",
-    "@kubb/plugin-zod": "5.0.0-alpha.29"
+    "@kubb/ast": "5.0.0-alpha.30",
+    "@kubb/core": "5.0.0-alpha.30",
+    "@kubb/plugin-ts": "5.0.0-alpha.30",
+    "@kubb/plugin-zod": "5.0.0-alpha.30"
   },
   "devDependencies": {
     "axios": "^1.14.0",

package/src/generators/classClientGenerator.tsx

@@ -1,6 +1,5 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import { transform } from '@kubb/ast'
 import type { OperationNode } from '@kubb/ast/types'
 import { defineGenerator } from '@kubb/core'
 import type { FabricFile } from '@kubb/fabric-core/types'
@@ -47,37 +46,35 @@ function resolveZodImportNames(node: OperationNode, zodResolver: PluginZod['reso
 
 export const classClientGenerator = defineGenerator<PluginClient>({
   name: 'classClient',
-  type: 'react',
-  Operations({ nodes, options, config, driver, resolver, adapter, plugin }) {
+  operations(nodes, options) {
+    const { adapter, config, driver, resolver, root } = this
     const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, wrapper } = options
     const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL
-    const root = path.resolve(config.root, config.output.path)
 
-    const pluginTs = driver.getPlugin<PluginTs>(pluginTsName)
+    const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs?.resolver) return null
 
     const tsResolver = pluginTs.resolver
     const tsPluginOptions = pluginTs.options
-    const pluginZod = parser === 'zod' ? driver.getPlugin<PluginZod>(pluginZodName) : undefined
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
     function buildOperationData(node: OperationNode): OperationData {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
       const typeFile = tsResolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         { root, output: tsPluginOptions?.output ?? output, group: tsPluginOptions?.group },
       )
       const zodFile =
         zodResolver && pluginZod?.options
           ? zodResolver.resolveFile(
-              { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+              { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
               { root, output: pluginZod.options.output ?? output, group: pluginZod.options.group },
             )
           : undefined
 
       return {
-        node: transformedNode,
-        name: resolver.resolveName(transformedNode.operationId),
+        node: node,
+        name: resolver.resolveName(node.operationId),
         tsResolver,
         zodResolver,
         typeFile,
@@ -181,18 +178,13 @@ export const classClientGenerator = defineGenerator<PluginClient>({
             </>
           ) : (
             <>
-              <File.Import name={['fetch']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import
-                name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-                root={file.path}
-                path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-                isTypeOnly
-              />
+              <File.Import name={['fetch']} root={file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} root={file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
             </>
           )}
 
-          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />}
+          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(root, '.kubb/config.ts')} />}
 
           {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
             const typeFile = typeFilesByPath.get(filePath)
@@ -240,12 +232,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
           {importPath ? (
             <File.Import name={['Client', 'RequestConfig']} path={importPath} isTypeOnly />
           ) : (
-            <File.Import
-              name={['Client', 'RequestConfig']}
-              root={wrapperFile.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
+            <File.Import name={['Client', 'RequestConfig']} root={wrapperFile.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
           )}
 
           {controllers.map(({ name, file }) => (
@@ -257,6 +244,6 @@ export const classClientGenerator = defineGenerator<PluginClient>({
       )
     }
 
-    return files
+    return <>{files}</>
   },
 })

package/src/generators/clientGenerator.tsx

@@ -1,9 +1,7 @@
 import path from 'node:path'
-import { caseParams, transform } from '@kubb/ast'
+import { caseParams } from '@kubb/ast'
 import { defineGenerator } from '@kubb/core'
-import type { PluginTs } from '@kubb/plugin-ts'
 import { pluginTsName } from '@kubb/plugin-ts'
-import type { PluginZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
 import { File } from '@kubb/react-fabric'
 import { Client } from '../components/Client'
@@ -12,13 +10,12 @@ import type { PluginClient } from '../types'
 
 export const clientGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  type: 'react',
-  Operation({ node, adapter, options, config, driver, resolver, plugin }) {
+  operation(node, options) {
+    const { adapter, config, driver, resolver, root } = this
     const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = options
     const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL
-    const root = path.resolve(config.root, config.output.path)
 
-    const pluginTs = driver.getPlugin<PluginTs>(pluginTsName)
+    const pluginTs = driver.getPlugin(pluginTsName)
 
     if (!pluginTs?.resolver) {
       return null
@@ -26,42 +23,34 @@ export const clientGenerator = defineGenerator<PluginClient>({
 
     const tsResolver = pluginTs.resolver
 
-    const pluginZod = parser === 'zod' ? driver.getPlugin<PluginZod>(pluginZodName) : undefined
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    const casedParams = caseParams(transformedNode.parameters, paramsCasing)
+    const casedParams = caseParams(node.parameters, paramsCasing)
     const pathParams = casedParams.filter((p) => p.in === 'path')
     const queryParams = casedParams.filter((p) => p.in === 'query')
     const headerParams = casedParams.filter((p) => p.in === 'header')
 
     const importedTypeNames = [
-      ...pathParams.map((p) => tsResolver.resolvePathParamsName(transformedNode, p)),
-      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(transformedNode, p)),
-      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(transformedNode, p)),
-      transformedNode.requestBody?.schema ? tsResolver.resolveDataName(transformedNode) : undefined,
-      tsResolver.resolveResponseName(transformedNode),
-      ...transformedNode.responses.map((res) => tsResolver.resolveResponseStatusName(transformedNode, res.statusCode)),
+      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
+      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
+      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
+      node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined,
+      tsResolver.resolveResponseName(node),
+      ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
     ].filter(Boolean)
 
     const importedZodNames =
       zodResolver && parser === 'zod'
-        ? [
-            zodResolver.resolveResponseName?.(transformedNode),
-            transformedNode.requestBody?.schema ? zodResolver.resolveDataName?.(transformedNode) : undefined,
-          ].filter(Boolean)
+        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
         : []
 
     const meta = {
-      name: resolver.resolveName(transformedNode.operationId),
-      urlName: `get${resolver.resolveName(transformedNode.operationId).charAt(0).toUpperCase()}${resolver.resolveName(transformedNode.operationId).slice(1)}Url`,
-      file: resolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
-        { root, output, group },
-      ),
+      name: resolver.resolveName(node.operationId),
+      urlName: `get${resolver.resolveName(node.operationId).charAt(0).toUpperCase()}${resolver.resolveName(node.operationId).slice(1)}Url`,
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
       fileTs: tsResolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         {
           root,
           output: pluginTs.options?.output ?? output,
@@ -71,7 +60,7 @@ export const clientGenerator = defineGenerator<PluginClient>({
       fileZod:
         zodResolver && pluginZod?.options
           ? zodResolver.resolveFile(
-              { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+              { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
               {
                 root,
                 output: pluginZod.options.output ?? output,
@@ -81,7 +70,7 @@ export const clientGenerator = defineGenerator<PluginClient>({
           : undefined,
     } as const
 
-    const isFormData = transformedNode.requestBody?.contentType === 'multipart/form-data'
+    const isFormData = node.requestBody?.contentType === 'multipart/form-data'
 
     return (
       <File
@@ -98,19 +87,17 @@ export const clientGenerator = defineGenerator<PluginClient>({
           </>
         ) : (
           <>
-            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
+            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={meta.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
+              path={path.resolve(root, '.kubb/fetch.ts')}
               isTypeOnly
             />
           </>
         )}
 
-        {isFormData && transformedNode.requestBody?.schema && (
-          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
-        )}
+        {isFormData && node.requestBody?.schema && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
 
         {meta.fileZod && importedZodNames.length > 0 && <File.Import name={importedZodNames as string[]} root={meta.file.path} path={meta.fileZod.path} />}
 
@@ -124,7 +111,7 @@ export const clientGenerator = defineGenerator<PluginClient>({
           pathParamsType={pathParamsType}
           paramsCasing={paramsCasing}
           paramsType={paramsType}
-          node={transformedNode}
+          node={node}
           tsResolver={tsResolver}
           isIndexable={urlType === 'export'}
           isExportable={urlType === 'export'}
@@ -138,7 +125,7 @@ export const clientGenerator = defineGenerator<PluginClient>({
           pathParamsType={pathParamsType}
           paramsCasing={paramsCasing}
           paramsType={paramsType}
-          node={transformedNode}
+          node={node}
           tsResolver={tsResolver}
           zodResolver={zodResolver}
           parser={parser}

package/src/generators/groupedClientGenerator.tsx

@@ -1,6 +1,4 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { transform } from '@kubb/ast'
 import { defineGenerator } from '@kubb/core'
 import type { FabricFile } from '@kubb/fabric-core/types'
 import { File, Function } from '@kubb/react-fabric'
@@ -8,10 +6,9 @@ import type { PluginClient } from '../types'
 
 export const groupedClientGenerator = defineGenerator<PluginClient>({
   name: 'groupedClient',
-  type: 'react',
-  Operations({ nodes, options, config, resolver, adapter, plugin }) {
+  operations(nodes, options) {
+    const { config, resolver, adapter, root } = this
     const { output, group } = options
-    const root = path.resolve(config.root, config.output.path)
 
     const controllers = nodes.reduce(
       (acc, operationNode) => {
@@ -23,16 +20,14 @@ export const groupedClientGenerator = defineGenerator<PluginClient>({
             return acc
           }
 
-          const transformedNode = plugin.transformer ? transform(operationNode, plugin.transformer) : operationNode
-
           const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group })
           const clientFile = resolver.resolveFile(
-            { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+            { name: operationNode.operationId, extname: '.ts', tag: operationNode.tags[0] ?? 'default', path: operationNode.path },
             { root, output, group },
           )
 
           const client = {
-            name: resolver.resolveName(transformedNode.operationId),
+            name: resolver.resolveName(operationNode.operationId),
             file: clientFile,
           }
 
@@ -50,27 +45,31 @@ export const groupedClientGenerator = defineGenerator<PluginClient>({
       [] as Array<{ name: string; file: FabricFile.File; clients: Array<{ name: string; file: FabricFile.File }> }>,
     )
 
-    return controllers.map(({ name, file, clients }) => {
-      return (
-        <File
-          key={file.path}
-          baseName={file.baseName}
-          path={file.path}
-          meta={file.meta}
-          banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
-        >
-          {clients.map((client) => (
-            <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
-          ))}
+    return (
+      <>
+        {controllers.map(({ name, file, clients }) => {
+          return (
+            <File
+              key={file.path}
+              baseName={file.baseName}
+              path={file.path}
+              meta={file.meta}
+              banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+              footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+            >
+              {clients.map((client) => (
+                <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
+              ))}
 
-          <File.Source name={name} isExportable isIndexable>
-            <Function export name={name}>
-              {`return { ${clients.map((client) => client.name).join(', ')} }`}
-            </Function>
-          </File.Source>
-        </File>
-      )
-    })
+              <File.Source name={name} isExportable isIndexable>
+                <Function export name={name}>
+                  {`return { ${clients.map((client) => client.name).join(', ')} }`}
+                </Function>
+              </File.Source>
+            </File>
+          )
+        })}
+      </>
+    )
   },
 })

package/src/generators/operationsGenerator.tsx

@@ -1,4 +1,3 @@
-import path from 'node:path'
 import { defineGenerator } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Operations } from '../components/Operations'
@@ -6,10 +5,9 @@ import type { PluginClient } from '../types'
 
 export const operationsGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  type: 'react',
-  Operations({ nodes, options, config, resolver, adapter }) {
+  operations(nodes, options) {
+    const { config, resolver, adapter, root } = this
     const { output, group } = options
-    const root = path.resolve(config.root, config.output.path)
 
     const name = 'operations'
     const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })

package/src/generators/staticClassClientGenerator.tsx

@@ -1,6 +1,5 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import { transform } from '@kubb/ast'
 import type { OperationNode } from '@kubb/ast/types'
 import { defineGenerator } from '@kubb/core'
 import type { FabricFile } from '@kubb/fabric-core/types'
@@ -46,37 +45,35 @@ function resolveZodImportNames(node: OperationNode, zodResolver: PluginZod['reso
 
 export const staticClassClientGenerator = defineGenerator<PluginClient>({
   name: 'staticClassClient',
-  type: 'react',
-  Operations({ nodes, options, config, driver, resolver, adapter, plugin }) {
+  operations(nodes, options) {
+    const { adapter, config, driver, resolver, root } = this
     const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = options
     const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL
-    const root = path.resolve(config.root, config.output.path)
 
-    const pluginTs = driver.getPlugin<PluginTs>(pluginTsName)
+    const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs?.resolver) return null
 
     const tsResolver = pluginTs.resolver
     const tsPluginOptions = pluginTs.options
-    const pluginZod = parser === 'zod' ? driver.getPlugin<PluginZod>(pluginZodName) : undefined
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
     function buildOperationData(node: OperationNode): OperationData {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
       const typeFile = tsResolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         { root, output: tsPluginOptions?.output ?? output, group: tsPluginOptions?.group },
       )
       const zodFile =
         zodResolver && pluginZod?.options
           ? zodResolver.resolveFile(
-              { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+              { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
               { root, output: pluginZod.options.output ?? output, group: pluginZod.options.group },
             )
           : undefined
 
       return {
-        node: transformedNode,
-        name: resolver.resolveName(transformedNode.operationId),
+        node: node,
+        name: resolver.resolveName(node.operationId),
         tsResolver,
         zodResolver,
         typeFile,
@@ -157,71 +154,75 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
       return { zodImportsByFile, zodFilesByPath }
     }
 
-    return 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, FabricFile.File>() }
-      const hasFormData = ops.some((op) => op.node.requestBody?.contentType === 'multipart/form-data')
-
-      return (
-        <File
-          key={file.path}
-          baseName={file.baseName}
-          path={file.path}
-          meta={file.meta}
-          banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
-        >
-          {importPath ? (
-            <>
-              <File.Import name={'fetch'} path={importPath} />
-              <File.Import name={['mergeConfig']} path={importPath} />
-              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
-            </>
-          ) : (
-            <>
-              <File.Import name={['fetch']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import
-                name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-                root={file.path}
-                path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-                isTypeOnly
+    return (
+      <>
+        {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, FabricFile.File>() }
+          const hasFormData = ops.some((op) => op.node.requestBody?.contentType === 'multipart/form-data')
+
+          return (
+            <File
+              key={file.path}
+              baseName={file.baseName}
+              path={file.path}
+              meta={file.meta}
+              banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+              footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+            >
+              {importPath ? (
+                <>
+                  <File.Import name={'fetch'} path={importPath} />
+                  <File.Import name={['mergeConfig']} path={importPath} />
+                  <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
+                </>
+              ) : (
+                <>
+                  <File.Import name={['fetch']} root={file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+                  <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+                  <File.Import
+                    name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
+                    root={file.path}
+                    path={path.resolve(root, '.kubb/fetch.ts')}
+                    isTypeOnly
+                  />
+                </>
+              )}
+
+              {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(root, '.kubb/config.ts')} />}
+
+              {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
+                const typeFile = typeFilesByPath.get(filePath)
+                if (!typeFile) return null
+                const importNames = Array.from(importSet).filter(Boolean)
+                if (importNames.length === 0) return null
+                return <File.Import key={filePath} name={importNames} root={file.path} path={typeFile.path} isTypeOnly />
+              })}
+
+              {parser === 'zod' &&
+                Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
+                  const zodFile = zodFilesByPath.get(filePath)
+                  if (!zodFile) return null
+                  const importNames = Array.from(importSet).filter(Boolean)
+                  if (importNames.length === 0) return null
+                  return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
+                })}
+
+              <StaticClassClient
+                name={name}
+                operations={ops}
+                baseURL={baseURL}
+                dataReturnType={dataReturnType}
+                pathParamsType={pathParamsType}
+                paramsCasing={paramsCasing}
+                paramsType={paramsType}
+                parser={parser}
               />
-            </>
-          )}
-
-          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />}
-
-          {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
-            const typeFile = typeFilesByPath.get(filePath)
-            if (!typeFile) return null
-            const importNames = Array.from(importSet).filter(Boolean)
-            if (importNames.length === 0) return null
-            return <File.Import key={filePath} name={importNames} root={file.path} path={typeFile.path} isTypeOnly />
-          })}
-
-          {parser === 'zod' &&
-            Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
-              const zodFile = zodFilesByPath.get(filePath)
-              if (!zodFile) return null
-              const importNames = Array.from(importSet).filter(Boolean)
-              if (importNames.length === 0) return null
-              return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
-            })}
-
-          <StaticClassClient
-            name={name}
-            operations={ops}
-            baseURL={baseURL}
-            dataReturnType={dataReturnType}
-            pathParamsType={pathParamsType}
-            paramsCasing={paramsCasing}
-            paramsType={paramsType}
-            parser={parser}
-          />
-        </File>
-      )
-    })
+            </File>
+          )
+        })}
+      </>
+    )
   },
 })