@kubb/plugin-client 5.0.0-alpha.8 → 5.0.0-beta.10

package/src/components/Client.tsx

@@ -1,16 +1,16 @@
+import { buildOperationComments, buildParamsMapping, buildRequestConfigType, getContentTypeInfo, getOperationParameters } from '@internals/shared'
 import { isValidVarName, URLPath } from '@internals/utils'
-import { getDefaultValue, isOptional, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getParamsMapping, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+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, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import { createFunctionParams } from '../functionParams.ts'
 import type { PluginClient } from '../types.ts'
-import { Url } from './Url.tsx'
+import { buildUrlParamsNode } from './Url.tsx'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   urlName?: string
   isExportable?: boolean
@@ -24,106 +24,50 @@ type Props = {
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  typeSchemas: OperationSchemas
-  zodSchemas: OperationSchemas | undefined
-  operation: Operation
-  children?: FabricReactNode
+  node: ast.OperationNode
+  tsResolver: ResolverTs
+  zodResolver?: ResolverZod
+  children?: KubbReactNode
 }
 
 type GetParamsProps = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['paramsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: ResolverTs
   isConfigurable: boolean
 }
 
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing,
-    })
-
-    const children = {
-      ...pathParams,
-      data: typeSchemas.request?.name
-        ? {
-            type: typeSchemas.request?.name,
-            optional: isOptional(typeSchemas.request?.schema),
-          }
-        : undefined,
-      params: typeSchemas.queryParams?.name
-        ? {
-            type: typeSchemas.queryParams?.name,
-            optional: isOptional(typeSchemas.queryParams?.schema),
-          }
-        : undefined,
-      headers: typeSchemas.headerParams?.name
-        ? {
-            type: typeSchemas.headerParams?.name,
-            optional: isOptional(typeSchemas.headerParams?.schema),
-          }
-        : undefined,
-    }
-
-    // Check if all children are optional or undefined
-    const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional)
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children,
-        default: allChildrenAreOptional ? '{}' : undefined,
-      },
-      config: isConfigurable
-        ? {
-            type: typeSchemas.request?.name
-              ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-              : 'Partial<RequestConfig> & { client?: Client }',
-            default: '{}',
-          }
-        : undefined,
-    })
-  }
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, {
-            typed: true,
-            casing: paramsCasing,
-          }),
-          default: getDefaultValue(typeSchemas.pathParams?.schema),
-        }
-      : undefined,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    config: isConfigurable
-      ? {
-          type: typeSchemas.request?.name
-            ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-            : 'Partial<RequestConfig> & { client?: Client }',
-          default: '{}',
-        }
-      : undefined,
+export function buildClientParamsNode({
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  node,
+  tsResolver,
+  isConfigurable,
+}: GetParamsProps): ast.FunctionParametersNode {
+  return ast.createOperationParams(node, {
+    paramsType,
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver: tsResolver,
+    extraParams: [
+      ...(isConfigurable
+        ? [
+            ast.createFunctionParameter({
+              name: 'config',
+              type: ast.createParamsType({
+                variant: 'reference',
+                name: buildRequestConfigType(node, tsResolver),
+              }),
+              default: '{}',
+            }),
+          ]
+        : []),
+    ],
   })
 }
 
@@ -132,60 +76,82 @@ export function Client({
   isExportable = true,
   isIndexable = true,
   returnType,
-  typeSchemas,
   baseURL,
   dataReturnType,
   parser,
-  zodSchemas,
   paramsType,
   paramsCasing,
   pathParamsType,
-  operation,
+  node,
+  tsResolver,
+  zodResolver,
   urlName,
   children,
   isConfigurable = true,
-}: Props): FabricReactNode {
-  const path = new URLPath(operation.path)
-  const contentType = operation.getContentType()
-  const isFormData = contentType === 'multipart/form-data'
+}: Props): KubbReactNode {
+  const path = new URLPath(node.path)
+  const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node)
+  const isFormData = !isMultipleContentTypes && contentType === 'multipart/form-data'
+
+  const { path: originalPathParams, query: originalQueryParams, header: originalHeaderParams } = getOperationParameters(node)
+  const { path: casedPathParams, query: casedQueryParams, header: casedHeaderParams } = getOperationParameters(node, { paramsCasing })
+
+  const pathParamsMapping = paramsCasing && !urlName ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
+  const queryParamsMapping = paramsCasing ? buildParamsMapping(originalQueryParams, casedQueryParams) : undefined
+  const headerParamsMapping = paramsCasing ? buildParamsMapping(originalHeaderParams, casedHeaderParams) : undefined
 
-  // Generate parameter mappings when paramsCasing is used
-  // Apply to pathParams, queryParams and headerParams
-  const pathParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : undefined
-  const queryParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.queryParams, { casing: paramsCasing }) : undefined
-  const headerParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.headerParams, { casing: paramsCasing }) : undefined
+  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
+  const responseName = tsResolver.resolveResponseName(node)
+  const queryParamsName = originalQueryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, originalQueryParams[0]!) : undefined
+  const headerParamsName = originalHeaderParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, originalHeaderParams[0]!) : undefined
+
+  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined
+  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined
+
+  const errorNames = node.responses
+    .filter((r) => {
+      const code = Number.parseInt(r.statusCode, 10)
+      return code >= 400
+    })
+    .map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
 
   const headers = [
-    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
-    typeSchemas.headerParams?.name ? (headerParamsMapping ? '...mappedHeaders' : '...headers') : undefined,
+    !isMultipleContentTypes && contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
+    headerParamsName ? (headerParamsMapping ? '...mappedHeaders' : '...headers') : undefined,
   ].filter(Boolean)
 
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-  const generics = [typeSchemas.response.name, TError, typeSchemas.request?.name || 'unknown'].filter(Boolean)
-  const params = getParams({
+  const generics = [responseName, TError, requestName || 'unknown'].filter(Boolean)
+  const paramsNode = buildClientParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
-    typeSchemas,
+    node,
+    tsResolver,
     isConfigurable,
   })
-  const urlParams = Url.getParams({
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+
+  const urlParamsNode = buildUrlParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
-    typeSchemas,
+    node,
+    tsResolver,
   })
+  const callPrinter = functionPrinter({ mode: 'call' })
+  const urlParamsCall = callPrinter.print(urlParamsNode) ?? ''
 
-  const clientParams = FunctionParams.factory({
+  const clientParams = createFunctionParams({
     config: {
       mode: 'object',
       children: {
         method: {
-          value: JSON.stringify(operation.method.toUpperCase()),
+          value: JSON.stringify(node.method.toUpperCase()),
         },
         url: {
-          value: urlName ? `${urlName}(${urlParams.toCall()}).url.toString()` : path.template,
+          value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : path.template,
         },
         baseURL:
           baseURL && !urlName
@@ -193,12 +159,18 @@ export function Client({
                 value: `\`${baseURL}\``,
               }
             : undefined,
-        params: typeSchemas.queryParams?.name ? (queryParamsMapping ? { value: 'mappedParams' } : {}) : undefined,
-        data: typeSchemas.request?.name
+        params: queryParamsName ? (queryParamsMapping ? { value: 'mappedParams' } : {}) : undefined,
+        data: requestName
           ? {
-              value: isFormData ? 'formData as FormData' : 'requestData',
+              value:
+                isMultipleContentTypes && hasFormData
+                  ? "contentType === 'multipart/form-data' ? formData as FormData : requestData"
+                  : isFormData
+                    ? 'formData as FormData'
+                    : 'requestData',
             }
           : undefined,
+        contentType: isConfigurable && isMultipleContentTypes ? {} : undefined,
         requestConfig: isConfigurable
           ? {
               mode: 'inlineSpread',
@@ -217,8 +189,8 @@ export function Client({
     children
   ) : (
     <>
-      {dataReturnType === 'full' && parser === 'zod' && zodSchemas && `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`}
-      {dataReturnType === 'data' && parser === 'zod' && zodSchemas && `return ${zodSchemas.response.name}.parse(res.data)`}
+      {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 === 'client' && 'return res'}
       {dataReturnType === 'data' && parser === 'client' && 'return res.data'}
     </>
@@ -233,18 +205,20 @@ export function Client({
           name={name}
           async
           export={isExportable}
-          params={params.toConstructor()}
+          params={paramsSignature}
           JSDoc={{
-            comments: getComments(operation),
+            comments: buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }),
           }}
           returnType={returnType}
         >
-          {isConfigurable ? 'const { client: request = fetch, ...requestConfig } = config' : ''}
+          {isConfigurable
+            ? `const { client: request = fetch, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ''}...requestConfig } = config`
+            : ''}
           <br />
           <br />
           {pathParamsMapping &&
             Object.entries(pathParamsMapping)
-              .filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName))
+              .filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName)
               .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
               .join('\n')}
           {pathParamsMapping && (
@@ -253,7 +227,7 @@ export function Client({
               <br />
             </>
           )}
-          {queryParamsMapping && typeSchemas.queryParams?.name && (
+          {queryParamsMapping && queryParamsName && (
             <>
               {`const mappedParams = params ? { ${Object.entries(queryParamsMapping)
                 .map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`)
@@ -262,7 +236,7 @@ export function Client({
               <br />
             </>
           )}
-          {headerParamsMapping && typeSchemas.headerParams?.name && (
+          {headerParamsMapping && headerParamsName && (
             <>
               {`const mappedHeaders = headers ? { ${Object.entries(headerParamsMapping)
                 .map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`)
@@ -271,11 +245,9 @@ export function Client({
               <br />
             </>
           )}
-          {parser === 'zod' && zodSchemas?.request?.name
-            ? `const requestData = ${zodSchemas.request.name}.parse(data)`
-            : typeSchemas?.request?.name && 'const requestData = data'}
+          {parser === 'zod' && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && 'const requestData = data'}
           <br />
-          {isFormData && typeSchemas?.request?.name && 'const formData = buildFormData(requestData)'}
+          {(isFormData || (isMultipleContentTypes && hasFormData)) && requestName && 'const formData = buildFormData(requestData)'}
           <br />
           {isConfigurable
             ? `const res = await request<${generics.join(', ')}>(${clientParams.toCall()})`
@@ -287,5 +259,3 @@ export function Client({
     </>
   )
 }
-
-Client.getParams = getParams

package/src/components/Operations.tsx

@@ -1,20 +1,20 @@
 import { URLPath } from '@internals/utils'
-import type { HttpMethod, Operation } from '@kubb/oas'
-import { Const, File } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { ast } from '@kubb/core'
+import { Const, File } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
 type OperationsProps = {
   name: string
-  operations: Array<Operation>
+  nodes: Array<ast.OperationNode>
 }
 
-export function Operations({ name, operations }: OperationsProps): FabricReactNode {
-  const operationsObject: Record<string, { path: string; method: HttpMethod }> = {}
+export function Operations({ name, nodes }: OperationsProps): KubbReactNode {
+  const operationsObject: Record<string, { path: string; method: string }> = {}
 
-  operations.forEach((operation) => {
-    operationsObject[operation.getOperationId()] = {
-      path: new URLPath(operation.path).URL,
-      method: operation.method,
+  nodes.forEach((node) => {
+    operationsObject[node.operationId] = {
+      path: new URLPath(node.path).URL,
+      method: node.method.toLowerCase(),
     }
   })
 

package/src/components/StaticClassClient.tsx

@@ -1,36 +1,41 @@
+import { buildOperationComments, getContentTypeInfo, getOperationParameters } from '@internals/shared'
 import { buildJSDoc, URLPath } from '@internals/utils'
-import type { Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments } from '@kubb/plugin-oas/utils'
-import { File, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { 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 { Client } from './Client.tsx'
+import { buildClassClientParams, buildFormDataLine, buildGenerics, buildHeaders, buildRequestDataLine, buildReturnStatement } from '../utils.ts'
+import { buildClientParamsNode } from './Client.tsx'
+
+type OperationData = {
+  node: ast.OperationNode
+  name: string
+  tsResolver: ResolverTs
+  zodResolver?: ResolverZod
+}
 
 type Props = {
   name: string
   isExportable?: boolean
   isIndexable?: boolean
-  operations: Array<{
-    operation: Operation
-    name: string
-    typeSchemas: OperationSchemas
-    zodSchemas: OperationSchemas | undefined
-  }>
+  operations: Array<OperationData>
   baseURL: string | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  children?: FabricReactNode
+  children?: KubbReactNode
 }
 
 type GenerateMethodProps = {
-  operation: Operation
+  node: ast.OperationNode
   name: string
-  typeSchemas: OperationSchemas
-  zodSchemas: OperationSchemas | undefined
+  tsResolver: ResolverTs
+  zodResolver?: ResolverZod
   baseURL: string | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
@@ -39,115 +44,13 @@ type GenerateMethodProps = {
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
 }
 
-function buildHeaders(contentType: string, hasHeaderParams: boolean): Array<string> {
-  return [
-    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
-    hasHeaderParams ? '...headers' : undefined,
-  ].filter(Boolean) as Array<string>
-}
-
-function buildGenerics(typeSchemas: OperationSchemas): Array<string> {
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  return [typeSchemas.response.name, TError, typeSchemas.request?.name || 'unknown'].filter(Boolean)
-}
-
-function buildClientParams({
-  operation,
-  path,
-  baseURL,
-  typeSchemas,
-  isFormData,
-  headers,
-}: {
-  operation: Operation
-  path: URLPath
-  baseURL: string | undefined
-  typeSchemas: OperationSchemas
-  isFormData: boolean
-  headers: Array<string>
-}) {
-  return FunctionParams.factory({
-    config: {
-      mode: 'object',
-      children: {
-        requestConfig: {
-          mode: 'inlineSpread',
-        },
-        method: {
-          value: JSON.stringify(operation.method.toUpperCase()),
-        },
-        url: {
-          value: path.template,
-        },
-        baseURL: baseURL
-          ? {
-              value: JSON.stringify(baseURL),
-            }
-          : undefined,
-        params: typeSchemas.queryParams?.name ? {} : undefined,
-        data: typeSchemas.request?.name
-          ? {
-              value: isFormData ? 'formData as FormData' : 'requestData',
-            }
-          : undefined,
-        headers: headers.length
-          ? {
-              value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
-            }
-          : undefined,
-      },
-    },
-  })
-}
-
-function buildRequestDataLine({
-  parser,
-  zodSchemas,
-  typeSchemas,
-}: {
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  zodSchemas: OperationSchemas | undefined
-  typeSchemas: OperationSchemas
-}): string {
-  if (parser === 'zod' && zodSchemas?.request?.name) {
-    return `const requestData = ${zodSchemas.request.name}.parse(data)`
-  }
-  if (typeSchemas?.request?.name) {
-    return 'const requestData = data'
-  }
-  return ''
-}
-
-function buildFormDataLine(isFormData: boolean, hasRequest: boolean): string {
-  return isFormData && hasRequest ? 'const formData = buildFormData(requestData)' : ''
-}
-
-function buildReturnStatement({
-  dataReturnType,
-  parser,
-  zodSchemas,
-}: {
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  zodSchemas: OperationSchemas | undefined
-}): string {
-  if (dataReturnType === 'full' && parser === 'zod' && zodSchemas) {
-    return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`
-  }
-  if (dataReturnType === 'data' && parser === 'zod' && zodSchemas) {
-    return `return ${zodSchemas.response.name}.parse(res.data)`
-  }
-  if (dataReturnType === 'full' && parser === 'client') {
-    return 'return res'
-  }
-  return 'return res.data'
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
 function generateMethod({
-  operation,
+  node,
   name,
-  typeSchemas,
-  zodSchemas,
+  tsResolver,
+  zodResolver,
   baseURL,
   dataReturnType,
   parser,
@@ -155,21 +58,24 @@ function generateMethod({
   paramsCasing,
   pathParamsType,
 }: GenerateMethodProps): string {
-  const path = new URLPath(operation.path, { casing: paramsCasing })
-  const contentType = operation.getContentType()
-  const isFormData = contentType === 'multipart/form-data'
-  const headers = buildHeaders(contentType, !!typeSchemas.headerParams?.name)
-  const generics = buildGenerics(typeSchemas)
-  const params = Client.getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable: true })
-  const clientParams = buildClientParams({ operation, path, baseURL, typeSchemas, isFormData, headers })
-  const jsdoc = buildJSDoc(getComments(operation))
+  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]!) : undefined
+  const headers = isMultipleContentTypes ? (headerParamsName ? ['...headers'] : []) : buildHeaders(contentType, !!headerParamsName)
+  const generics = buildGenerics(node, tsResolver)
+  const paramsNode = buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable: true })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+  const clientParams = buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers })
+  const jsdoc = buildJSDoc(buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }))
 
-  const requestDataLine = buildRequestDataLine({ parser, zodSchemas, typeSchemas })
-  const formDataLine = buildFormDataLine(isFormData, !!typeSchemas?.request?.name)
-  const returnStatement = buildReturnStatement({ dataReturnType, parser, zodSchemas })
+  const requestDataLine = buildRequestDataLine({ parser, node, zodResolver })
+  const formDataLine = buildFormDataLine(isFormData || (isMultipleContentTypes && hasFormData), !!node.requestBody?.content?.[0]?.schema)
+  const returnStatement = buildReturnStatement({ dataReturnType, parser, node, zodResolver })
 
   const methodBody = [
-    'const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)',
+    `const { client: request = fetch, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ''}...requestConfig } = mergeConfig(this.#config, config)`,
     '',
     requestDataLine,
     formDataLine,
@@ -180,8 +86,7 @@ function generateMethod({
     .map((line) => `    ${line}`)
     .join('\n')
 
-  // Indent static method by 2 spaces, body by 4 spaces (matching snapshot)
-  return `${jsdoc}  static async ${name}(${params.toConstructor()}) {\n${methodBody}\n  }`
+  return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${methodBody}\n  }`
 }
 
 export function StaticClassClient({
@@ -196,13 +101,13 @@ export function StaticClassClient({
   paramsCasing,
   pathParamsType,
   children,
-}: Props): FabricReactNode {
-  const methods = operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) =>
+}: Props): KubbReactNode {
+  const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver }) =>
     generateMethod({
-      operation,
+      node,
       name: methodName,
-      typeSchemas,
-      zodSchemas,
+      tsResolver,
+      zodResolver,
       baseURL,
       dataReturnType,
       parser,
@@ -221,4 +126,3 @@ export function StaticClassClient({
     </File.Source>
   )
 }
-StaticClassClient.getParams = Client.getParams