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

package/src/components/StaticClassClient.tsx

@@ -1,153 +0,0 @@
-import { buildOperationComments, getContentTypeInfo, getOperationParameters } from '@internals/shared'
-import { Url } from '@internals/utils'
-import { buildJSDoc, stringify } from '@kubb/ast/utils'
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import type { ResolverZod } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginClient } from '../types.ts'
-import {
-  buildClassClientParams,
-  buildFormDataLine,
-  buildGenerics,
-  buildHeaders,
-  buildQueryParamsLine,
-  buildRequestDataLine,
-  buildReturnStatement,
-  resolveQueryParamsParser,
-} from '../utils.ts'
-import { buildClientParamsNode } from './Client.tsx'
-
-type OperationData = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver?: ResolverZod | null
-}
-
-type Props = {
-  name: string
-  isExportable?: boolean
-  isIndexable?: boolean
-  operations: Array<OperationData>
-  baseURL: string | null | undefined
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  paramsType: PluginClient['resolvedOptions']['pathParamsType']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  children?: KubbReactNode
-}
-
-type GenerateMethodProps = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver?: ResolverZod | null
-  baseURL: string | null | undefined
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  paramsType: PluginClient['resolvedOptions']['paramsType']
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-function generateMethod({
-  node,
-  name,
-  tsResolver,
-  zodResolver,
-  baseURL,
-  dataReturnType,
-  parser,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-}: GenerateMethodProps): string {
-  if (!ast.isHttpOperationNode(node)) return ''
-  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, { dataReturnType, zodResolver, parser })
-  const paramsNode = buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, 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,
-    url: Url.toTemplateString(node.path, { casing: paramsCasing }),
-    baseURL,
-    tsResolver,
-    isFormData,
-    isMultipleContentTypes,
-    hasFormData,
-    headers,
-    zodQueryParamsName,
-  })
-  const jsdoc = buildJSDoc(buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }))
-
-  const requestDataLine = buildRequestDataLine({ parser, 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, tsResolver })
-
-  const methodBody = [
-    `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,
-  ]
-    .filter(Boolean)
-    .map((line) => `    ${line}`)
-    .join('\n')
-
-  return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${methodBody}\n  }`
-}
-
-export function StaticClassClient({
-  name,
-  isExportable = true,
-  isIndexable = true,
-  operations,
-  baseURL,
-  dataReturnType,
-  parser,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  children,
-}: Props): KubbReactNode {
-  const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver }) =>
-    generateMethod({
-      node,
-      name: methodName,
-      tsResolver,
-      zodResolver,
-      baseURL,
-      dataReturnType,
-      parser,
-      paramsType,
-      paramsCasing,
-      pathParamsType,
-    }),
-  )
-
-  const classCode = `export class ${name} {\n  static #config: Partial<RequestConfig> & { client?: Client } = {}\n\n${methods.join('\n\n')}\n}`
-
-  return (
-    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      {classCode}
-      {children}
-    </File.Source>
-  )
-}

package/src/components/Url.tsx

@@ -1,90 +0,0 @@
-import { buildParamsMapping, getOperationParameters } from '@internals/shared'
-import { isValidVarName, Url as UrlHelper } from '@internals/utils'
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { Const, File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginClient } from '../types.ts'
-
-type Props = {
-  name: string
-  isExportable?: boolean
-  isIndexable?: boolean
-
-  baseURL: string | null | undefined
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  paramsType: PluginClient['resolvedOptions']['pathParamsType']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  paramsType: PluginClient['resolvedOptions']['paramsType']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-export function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
-  // Build a URL-only node with only path params (no body, query, header)
-  const urlNode: ast.OperationNode = {
-    ...node,
-    parameters: node.parameters.filter((p) => p.in === 'path'),
-    requestBody: undefined,
-  }
-
-  return ast.createOperationParams(urlNode, {
-    paramsType: paramsType === 'object' ? 'object' : 'inline',
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver: tsResolver,
-  })
-}
-
-export function Url({
-  name,
-  isExportable = true,
-  isIndexable = true,
-  baseURL,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  if (!ast.isHttpOperationNode(node)) return null
-
-  const paramsNode = buildUrlParamsNode({
-    paramsType,
-    paramsCasing,
-    pathParamsType,
-    node,
-    tsResolver,
-  })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  const { path: originalPathParams } = getOperationParameters(node)
-  const { path: casedPathParams } = getOperationParameters(node, { paramsCasing })
-  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : null
-
-  return (
-    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      <Function name={name} export={isExportable} params={paramsSignature}>
-        {pathParamsMapping &&
-          Object.entries(pathParamsMapping)
-            .filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName)
-            .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
-            .join('\n')}
-        {pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && <br />}
-        <Const name={'res'}>{`{ method: '${node.method.toUpperCase()}', url: ${UrlHelper.toTemplateString(node.path, { prefix: baseURL })} as const }`}</Const>
-        <br />
-        return res
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/WrapperClient.tsx

@@ -1,33 +0,0 @@
-import { File } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-
-type ClientController = {
-  className: string
-  propertyName: string
-}
-
-type Props = {
-  name: string
-  controllers: Array<ClientController>
-  isExportable?: boolean
-  isIndexable?: boolean
-}
-
-export function WrapperClient({ name, controllers, isExportable = true, isIndexable = true }: Props): KubbReactNode {
-  const properties = controllers.map(({ className, propertyName }) => `  readonly ${propertyName}: ${className}`).join('\n')
-  const assignments = controllers.map(({ className, propertyName }) => `    this.${propertyName} = new ${className}(config)`).join('\n')
-
-  const classCode = `export class ${name} {
-${properties}
-
-  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
-${assignments}
-  }
-}`
-
-  return (
-    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      {classCode}
-    </File.Source>
-  )
-}

package/src/functionParams.ts

@@ -1,118 +0,0 @@
-import { ast } from '@kubb/core'
-import { functionPrinter } from '@kubb/plugin-ts'
-
-type ParamLeaf = {
-  type?: string
-  optional?: boolean
-  default?: string
-  value?: string
-  mode?: 'inlineSpread'
-}
-
-type ParamGroup = {
-  mode: 'object' | 'inlineSpread'
-  children: Record<string, ParamLeaf | null | undefined>
-  default?: string
-}
-
-type ParamSpec = ParamLeaf | ParamGroup
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function isGroup(spec: ParamSpec): spec is ParamGroup {
-  return 'children' in spec
-}
-
-function createType(type?: string) {
-  return type ? ast.createParamsType({ variant: 'reference', name: type }) : null
-}
-
-function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParameterNode {
-  if (spec.default !== undefined) {
-    return ast.createFunctionParameter({
-      name,
-      type: createType(spec.type) ?? undefined,
-      default: spec.default,
-      rest: spec.mode === 'inlineSpread',
-    })
-  }
-
-  return ast.createFunctionParameter({
-    name,
-    type: createType(spec.type) ?? undefined,
-    optional: !!spec.optional,
-    rest: spec.mode === 'inlineSpread',
-  })
-}
-
-function createDeclarationParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
-  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!)),
-    })
-  }
-
-  return createDeclarationLeaf(name, spec)
-}
-
-function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
-  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({
-    name: spec.value ?? name,
-    rest: spec.mode === 'inlineSpread',
-  })
-}
-
-/**
- * Creates function parameter builders for generating function signatures and calls.
- * Returns utilities to output constructor signatures (`toConstructor()`) or call expressions (`toCall()`).
- */
-export function createFunctionParams(params: Record<string, ParamSpec | null | undefined>) {
-  const entries = Object.entries(params).filter(([, spec]) => spec != null) as Array<[string, ParamSpec]>
-
-  return {
-    toConstructor() {
-      return (
-        declarationPrinter.print(
-          ast.createFunctionParameters({
-            params: entries.map(([name, spec]) => createDeclarationParam(name, spec)),
-          }),
-        ) ?? ''
-      )
-    },
-    toCall() {
-      return (
-        callPrinter.print(
-          ast.createFunctionParameters({
-            params: entries.map(([name, spec]) => createCallParam(name, spec)),
-          }),
-        ) ?? ''
-      )
-    },
-  }
-}

package/src/generators/classClientGenerator.tsx

@@ -1,261 +0,0 @@
-import path from 'node:path'
-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, jsxRenderer } from '@kubb/renderer-jsx'
-import { ClassClient } from '../components/ClassClient'
-import { WrapperClient } from '../components/WrapperClient'
-import type { PluginClient } from '../types'
-import { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from '../utils.ts'
-
-type OperationData = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver: ResolverZod | null
-  typeFile: ast.FileNode
-  zodFile: ast.FileNode | null
-}
-
-type Controller = {
-  name: string
-  propertyName: string
-  file: ast.FileNode
-  operations: Array<OperationData>
-}
-
-function resolveTypeImportNames(node: ast.OperationNode, tsResolver: ResolverTs): Array<string> {
-  return resolveOperationTypeNames(node, tsResolver, { order: 'body-response-first' })
-}
-
-function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod, parser: PluginClient['resolvedOptions']['parser']): Array<string> {
-  const { query: queryParams } = getOperationParameters(node)
-  const names: Array<string | null | undefined> = [
-    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))
-}
-
-/**
- * Built-in `operations` generator for `@kubb/plugin-client` when
- * `clientType: 'class'`. Emits one class per tag, with one instance method
- * per operation and a shared constructor for request configuration.
- */
-export const classClientGenerator = defineGenerator<PluginClient>({
-  name: 'classClient',
-  renderer: jsxRenderer,
-  operations(nodes, ctx) {
-    const { config, driver, resolver, root } = ctx
-    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = ctx.options
-    const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-
-    const tsResolver = driver.getResolver(pluginTsName)
-    const tsPluginOptions = pluginTs.options
-    const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
-
-    function buildOperationData(node: ast.OperationNode): OperationData {
-      const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-        root,
-        output: tsPluginOptions?.output ?? output,
-        group: tsPluginOptions?.group,
-      })
-      const zodFile =
-        zodResolver && pluginZod?.options
-          ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-              root,
-              output: pluginZod.options?.output ?? output,
-              group: pluginZod.options?.group ?? undefined,
-            })
-          : null
-
-      return {
-        node: node,
-        name: resolver.resolveName(node.operationId),
-        tsResolver,
-        zodResolver,
-        typeFile,
-        zodFile,
-      }
-    }
-
-    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.resolveClassName('Client')
-
-      if (!tag && !group) {
-        const name = resolver.resolveClassName('ApiClient')
-        const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
-        const operationData = buildOperationData(operationNode)
-        const previous = acc.find((item) => item.file.path === file.path)
-
-        if (previous) {
-          previous.operations.push(operationData)
-        } else {
-          acc.push({ name, propertyName: resolver.resolveClientPropertyName(name), file, operations: [operationData] })
-        }
-        return acc
-      }
-
-      if (tag) {
-        const name = groupName
-        const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group: group ?? undefined })
-        const operationData = buildOperationData(operationNode)
-        const previous = acc.find((item) => item.file.path === file.path)
-
-        if (previous) {
-          previous.operations.push(operationData)
-        } else {
-          acc.push({ name, propertyName: resolver.resolveClientPropertyName(name), file, operations: [operationData] })
-        }
-      }
-
-      return acc
-    }, [] as Array<Controller>)
-
-    function collectTypeImports(ops: Array<OperationData>) {
-      const typeImportsByFile = new Map<string, Set<string>>()
-      const typeFilesByPath = new Map<string, ast.FileNode>()
-
-      ops.forEach((op) => {
-        const names = resolveTypeImportNames(op.node, tsResolver)
-        if (!typeImportsByFile.has(op.typeFile.path)) {
-          typeImportsByFile.set(op.typeFile.path, new Set())
-        }
-        const imports = typeImportsByFile.get(op.typeFile.path)!
-        names.forEach((n) => {
-          imports.add(n)
-        })
-        typeFilesByPath.set(op.typeFile.path, op.typeFile)
-      })
-
-      return { typeImportsByFile, typeFilesByPath }
-    }
-
-    function collectZodImports(ops: Array<OperationData>) {
-      const zodImportsByFile = new Map<string, Set<string>>()
-      const zodFilesByPath = new Map<string, ast.FileNode>()
-
-      ops.forEach((op) => {
-        if (!op.zodFile || !zodResolver) return
-        const names = resolveZodImportNames(op.node, zodResolver, parser)
-        if (!zodImportsByFile.has(op.zodFile.path)) {
-          zodImportsByFile.set(op.zodFile.path, new Set())
-        }
-        const imports = zodImportsByFile.get(op.zodFile.path)!
-        names.forEach((n) => {
-          imports.add(n)
-        })
-        zodFilesByPath.set(op.zodFile.path, op.zodFile)
-      })
-
-      return { zodImportsByFile, zodFilesByPath }
-    }
-
-    const files = controllers.map(({ name, file, operations: ops }) => {
-      const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
-      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 (
-        <File
-          key={file.path}
-          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 } })}
-        >
-          {importPath ? (
-            <>
-              <File.Import name={'client'} path={importPath} />
-              <File.Import name={['mergeConfig']} path={importPath} />
-              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
-            </>
-          ) : (
-            <>
-              <File.Import name={['client']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
-              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
-              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-            </>
-          )}
-
-          {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
-            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 />
-          })}
-
-          {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)
-              if (importNames.length === 0) return null
-              return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
-            })}
-
-          <ClassClient
-            name={name}
-            operations={ops}
-            baseURL={baseURL}
-            dataReturnType={dataReturnType}
-            pathParamsType={pathParamsType}
-            paramsCasing={paramsCasing}
-            paramsType={paramsType}
-            parser={parser}
-          />
-        </File>
-      )
-    })
-
-    if (sdk) {
-      const sdkFile = resolver.resolveFile({ name: sdk.className, extname: '.ts' }, { root, output, group: group ?? undefined })
-
-      files.push(
-        <File
-          key={sdkFile.path}
-          baseName={sdkFile.baseName}
-          path={sdkFile.path}
-          meta={sdkFile.meta}
-          banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
-          footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
-        >
-          {importPath ? (
-            <File.Import name={['Client', 'RequestConfig']} path={importPath} isTypeOnly />
-          ) : (
-            <File.Import name={['Client', 'RequestConfig']} root={sdkFile.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-          )}
-
-          {controllers.map(({ name, file }) => (
-            <File.Import key={name} name={[name]} root={sdkFile.path} path={file.path} />
-          ))}
-
-          <WrapperClient name={sdk.className} controllers={controllers.map(({ name, propertyName }) => ({ className: name, propertyName }))} />
-        </File>,
-      )
-    }
-
-    return <>{files}</>
-  },
-})