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

package/src/components/Client.tsx

@@ -1,4 +1,14 @@
-import { isValidVarName, URLPath } from '@internals/utils'
+import {
+  buildOperationComments,
+  buildParamsMapping,
+  buildRequestConfigType,
+  getContentTypeInfo,
+  getOperationParameters,
+  getResponseType,
+  resolveSuccessNames,
+} from '@internals/shared'
+import { isValidVarName, Url } from '@internals/utils'
+import { stringify } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
@@ -7,8 +17,8 @@ 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 { buildParamsMapping, getComments } from '../utils.ts'
-import { Url } from './Url.tsx'
+import { buildStatusUnionType, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from '../utils.ts'
+import { buildUrlParamsNode } from './Url.tsx'
 
 type Props = {
   name: string
@@ -18,7 +28,7 @@ type Props = {
   isConfigurable?: boolean
   returnType?: string
 
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
@@ -26,7 +36,7 @@ type Props = {
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   node: ast.OperationNode
   tsResolver: ResolverTs
-  zodResolver?: ResolverZod
+  zodResolver?: ResolverZod | null
   children?: KubbReactNode
 }
 
@@ -41,26 +51,33 @@ type GetParamsProps = {
 
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }: GetParamsProps): ast.FunctionParametersNode {
-  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : 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: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }',
+    extraParams: [
+      ...(isConfigurable
+        ? [
+            ast.createFunctionParameter({
+              name: 'config',
+              type: ast.createParamsType({
+                variant: 'reference',
+                name: buildRequestConfigType(node, tsResolver),
+              }),
+              default: '{}',
             }),
-            default: '{}',
-          }),
-        ]
-      : [],
+          ]
+        : []),
+    ],
   })
 }
 
@@ -82,28 +99,31 @@ export function Client({
   children,
   isConfigurable = true,
 }: Props): KubbReactNode {
-  const path = new URLPath(node.path)
-  const contentType = node.requestBody?.content?.[0]?.contentType ?? 'application/json'
-  const isFormData = contentType === 'multipart/form-data'
+  if (!ast.isHttpOperationNode(node)) return null
+  const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node)
+  const isFormData = !isMultipleContentTypes && contentType === 'multipart/form-data'
+  const responseType = getResponseType(node)
 
-  const originalPathParams = node.parameters.filter((p) => p.in === 'path')
-  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
-  const originalQueryParams = node.parameters.filter((p) => p.in === 'query')
-  const casedQueryParams = ast.caseParams(originalQueryParams, paramsCasing)
-  const originalHeaderParams = node.parameters.filter((p) => p.in === 'header')
-  const casedHeaderParams = ast.caseParams(originalHeaderParams, paramsCasing)
+  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
+  const pathParamsMapping = paramsCasing && !urlName ? buildParamsMapping(originalPathParams, casedPathParams) : null
+  const queryParamsMapping = paramsCasing ? buildParamsMapping(originalQueryParams, casedQueryParams) : null
+  const headerParamsMapping = paramsCasing ? buildParamsMapping(originalHeaderParams, casedHeaderParams) : null
 
-  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 requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null
+  const successNames = resolveSuccessNames(node, tsResolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
+  const queryParamsName = originalQueryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, originalQueryParams[0]!) : null
+  const headerParamsName = originalHeaderParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, originalHeaderParams[0]!) : null
 
-  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined
-  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined
+  const requestParser = resolveRequestParser(parser)
+  const responseParser = resolveResponseParser(parser)
+  const zodResponseName = zodResolver && responseParser === 'zod' ? zodResolver.resolveResponseName?.(node) : null
+  const zodRequestName = zodResolver && requestParser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null
+  const queryParamsParser = resolveQueryParamsParser(parser)
+  const zodQueryParamsName =
+    zodResolver && queryParamsParser === 'zod' && originalQueryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, originalQueryParams[0]!) : null
 
   const errorNames = node.responses
     .filter((r) => {
@@ -113,14 +133,18 @@ export function Client({
     .map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
 
   const headers = [
-    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
-    headerParamsName ? (headerParamsMapping ? '...mappedHeaders' : '...headers') : undefined,
+    !isMultipleContentTypes && contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : null,
+    headerParamsName ? (headerParamsMapping ? '...mappedHeaders' : '...headers') : null,
   ].filter(Boolean)
 
   const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-  const generics = [responseName, TError, requestName || 'unknown'].filter(Boolean)
-  const paramsNode = getParams({
+  const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
+  const genericsResponseName = dataReturnType === 'full' ? (allStatusNames.length > 0 ? allStatusNames.join(' | ') : responseName) : responseName
+  // z.output<> reflects the post-transform type (e.g. date coercion turns Date → string), avoiding a compile error on the generated call
+  const requestGenericType = parser === 'zod' && zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || 'unknown'
+  const generics = [genericsResponseName, TError, requestGenericType].filter(Boolean)
+  const paramsNode = buildClientParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
@@ -130,7 +154,7 @@ export function Client({
   })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  const urlParamsNode = Url.getParams({
+  const urlParamsNode = buildUrlParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
@@ -145,45 +169,58 @@ export function Client({
       mode: 'object',
       children: {
         method: {
-          value: JSON.stringify(node.method.toUpperCase()),
+          value: stringify(node.method.toUpperCase()),
         },
         url: {
-          value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : path.template,
+          value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : Url.toTemplateString(node.path),
         },
         baseURL:
           baseURL && !urlName
             ? {
                 value: `\`${baseURL}\``,
               }
-            : undefined,
-        params: queryParamsName ? (queryParamsMapping ? { value: 'mappedParams' } : {}) : undefined,
+            : null,
+        params: queryParamsName ? (zodQueryParamsName ? { value: 'requestParams' } : queryParamsMapping ? { value: 'mappedParams' } : {}) : null,
         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,
+          : null,
+        contentType: isConfigurable && isMultipleContentTypes ? {} : null,
+        responseType: responseType ? { value: stringify(responseType) } : null,
         requestConfig: isConfigurable
           ? {
               mode: 'inlineSpread',
             }
-          : undefined,
+          : null,
         headers: headers.length
           ? {
               value: isConfigurable ? `{ ${headers.join(', ')}, ...requestConfig.headers }` : `{ ${headers.join(', ')} }`,
             }
-          : undefined,
+          : null,
       },
     },
   })
 
+  const statusUnionType = dataReturnType === 'full' ? buildStatusUnionType(node, tsResolver) : null
+
   const childrenElement = children ? (
     children
   ) : (
     <>
-      {dataReturnType === 'full' && parser === 'zod' && zodResponseName && `return {...res, data: ${zodResponseName}.parse(res.data)}`}
-      {dataReturnType === 'data' && parser === 'zod' && zodResponseName && `return ${zodResponseName}.parse(res.data)`}
-      {dataReturnType === 'full' && parser === 'client' && 'return res'}
-      {dataReturnType === 'data' && parser === 'client' && 'return res.data'}
+      {dataReturnType === 'full' &&
+        responseParser === 'zod' &&
+        zodResponseName &&
+        statusUnionType &&
+        `return {...res, data: ${zodResponseName}.parse(res.data)} as ${statusUnionType}`}
+      {dataReturnType === 'full' && responseParser !== 'zod' && statusUnionType && `return res as ${statusUnionType}`}
+      {dataReturnType === 'data' && responseParser === 'zod' && zodResponseName && `return ${zodResponseName}.parse(res.data)`}
+      {dataReturnType === 'data' && responseParser !== 'zod' && 'return res.data'}
     </>
   )
 
@@ -198,31 +235,26 @@ export function Client({
           export={isExportable}
           params={paramsSignature}
           JSDoc={{
-            comments: getComments(node),
+            comments: buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }),
           }}
           returnType={returnType}
         >
-          {isConfigurable ? 'const { client: request = fetch, ...requestConfig } = config' : ''}
-          <br />
+          {isConfigurable
+            ? `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ''}...requestConfig } = config`
+            : ''}
           <br />
           {pathParamsMapping &&
             Object.entries(pathParamsMapping)
               .filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName)
               .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
               .join('\n')}
-          {pathParamsMapping && (
-            <>
-              <br />
-              <br />
-            </>
-          )}
+          {pathParamsMapping && <br />}
           {queryParamsMapping && queryParamsName && (
             <>
               {`const mappedParams = params ? { ${Object.entries(queryParamsMapping)
                 .map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`)
                 .join(', ')} } : undefined`}
               <br />
-              <br />
             </>
           )}
           {headerParamsMapping && headerParamsName && (
@@ -231,16 +263,15 @@ export function Client({
                 .map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`)
                 .join(', ')} } : undefined`}
               <br />
-              <br />
             </>
           )}
-          {parser === 'zod' && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && 'const requestData = data'}
-          <br />
-          {isFormData && requestName && 'const formData = buildFormData(requestData)'}
+          {requestParser === 'zod' && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && 'const requestData = data'}
+          {zodQueryParamsName && `const requestParams = ${zodQueryParamsName}.parse(params)`}
+          {(isFormData || (isMultipleContentTypes && hasFormData)) && requestName && 'const formData = buildFormData(requestData)'}
           <br />
           {isConfigurable
             ? `const res = await request<${generics.join(', ')}>(${clientParams.toCall()})`
-            : `const res = await fetch<${generics.join(', ')}>(${clientParams.toCall()})`}
+            : `const res = await client<${generics.join(', ')}>(${clientParams.toCall()})`}
           <br />
           {childrenElement}
         </Function>
@@ -248,5 +279,3 @@ export function Client({
     </>
   )
 }
-
-Client.getParams = getParams

package/src/components/StaticClassClient.tsx

@@ -1,19 +1,30 @@
-import { buildJSDoc, URLPath } from '@internals/utils'
-import type { ast } from '@kubb/core'
+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, buildRequestDataLine, buildReturnStatement, getComments } from '../utils.ts'
-import { Client } from './Client.tsx'
+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
+  zodResolver?: ResolverZod | null
 }
 
 type Props = {
@@ -21,7 +32,7 @@ type Props = {
   isExportable?: boolean
   isIndexable?: boolean
   operations: Array<OperationData>
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
@@ -34,8 +45,8 @@ type GenerateMethodProps = {
   node: ast.OperationNode
   name: string
   tsResolver: ResolverTs
-  zodResolver?: ResolverZod
-  baseURL: string | undefined
+  zodResolver?: ResolverZod | null
+  baseURL: string | null | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   paramsType: PluginClient['resolvedOptions']['paramsType']
@@ -57,28 +68,41 @@ function generateMethod({
   paramsCasing,
   pathParamsType,
 }: GenerateMethodProps): string {
-  const path = new URLPath(node.path, { casing: paramsCasing })
-  const contentType = node.requestBody?.content?.[0]?.contentType ?? 'application/json'
-  const isFormData = contentType === 'multipart/form-data'
-  const headerParamsName =
-    node.parameters.filter((p) => p.in === 'header').length > 0
-      ? tsResolver.resolveHeaderParamsName(node, node.parameters.filter((p) => p.in === 'header')[0]!)
-      : undefined
-  const headers = buildHeaders(contentType, !!headerParamsName)
-  const generics = buildGenerics(node, tsResolver)
-  const paramsNode = Client.getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable: true })
+  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 clientParams = buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, headers })
-  const jsdoc = buildJSDoc(getComments(node))
+  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 formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.content?.[0]?.schema)
-  const returnStatement = buildReturnStatement({ dataReturnType, 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 = fetch, ...requestConfig } = mergeConfig(this.#config, config)',
+    `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ''}...requestConfig } = mergeConfig(this.#config, config)`,
     '',
     requestDataLine,
+    queryParamsLine,
     formDataLine,
     `const res = await request<${generics.join(', ')}>(${clientParams.toCall()})`,
     returnStatement,
@@ -127,4 +151,3 @@ export function StaticClassClient({
     </File.Source>
   )
 }
-StaticClassClient.getParams = Client.getParams

package/src/components/Url.tsx

@@ -1,18 +1,18 @@
-import { isValidVarName, URLPath } from '@internals/utils'
+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'
-import { buildParamsMapping } from '../utils.ts'
 
 type Props = {
   name: string
   isExportable?: boolean
   isIndexable?: boolean
 
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
@@ -30,7 +30,7 @@ type GetParamsProps = {
 
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
+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,
@@ -57,9 +57,9 @@ export function Url({
   node,
   tsResolver,
 }: Props): KubbReactNode {
-  const path = new URLPath(node.path)
+  if (!ast.isHttpOperationNode(node)) return null
 
-  const paramsNode = getParams({
+  const paramsNode = buildUrlParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
@@ -68,9 +68,9 @@ export function Url({
   })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  const originalPathParams = node.parameters.filter((p) => p.in === 'path')
-  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
-  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
+  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}>
@@ -81,12 +81,10 @@ export function Url({
             .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
             .join('\n')}
         {pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && <br />}
-        <Const name={'res'}>{`{ method: '${node.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`}</Const>
+        <Const name={'res'}>{`{ method: '${node.method.toUpperCase()}', url: ${UrlHelper.toTemplateString(node.path, { prefix: baseURL })} as const }`}</Const>
         <br />
         return res
       </Function>
     </File.Source>
   )
 }
-
-Url.getParams = getParams

package/src/components/WrapperClient.tsx

@@ -1,17 +1,21 @@
-import { camelCase } from '@internals/utils'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
+type ClientController = {
+  className: string
+  propertyName: string
+}
+
 type Props = {
   name: string
-  classNames: Array<string>
+  controllers: Array<ClientController>
   isExportable?: boolean
   isIndexable?: boolean
 }
 
-export function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }: Props): KubbReactNode {
-  const properties = classNames.map((className) => `  readonly ${camelCase(className)}: ${className}`).join('\n')
-  const assignments = classNames.map((className) => `    this.${camelCase(className)} = new ${className}(config)`).join('\n')
+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}

package/src/functionParams.ts

@@ -11,7 +11,7 @@ type ParamLeaf = {
 
 type ParamGroup = {
   mode: 'object' | 'inlineSpread'
-  children: Record<string, ParamLeaf | undefined>
+  children: Record<string, ParamLeaf | null | undefined>
   default?: string
 }
 
@@ -25,14 +25,14 @@ function isGroup(spec: ParamSpec): spec is ParamGroup {
 }
 
 function createType(type?: string) {
-  return type ? ast.createParamsType({ variant: 'reference', name: type }) : undefined
+  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),
+      type: createType(spec.type) ?? undefined,
       default: spec.default,
       rest: spec.mode === 'inlineSpread',
     })
@@ -40,7 +40,7 @@ function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParam
 
   return ast.createFunctionParameter({
     name,
-    type: createType(spec.type),
+    type: createType(spec.type) ?? undefined,
     optional: !!spec.optional,
     rest: spec.mode === 'inlineSpread',
   })
@@ -52,7 +52,7 @@ function createDeclarationParam(name: string, spec: ParamSpec): ast.FunctionPara
       inline: spec.mode === 'inlineSpread',
       default: spec.default,
       properties: Object.entries(spec.children)
-        .filter(([, child]) => child !== undefined)
+        .filter(([, child]) => child != null)
         .map(([childName, child]) => createDeclarationLeaf(childName, child!)),
     })
   }
@@ -65,7 +65,7 @@ function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNo
     return ast.createParameterGroup({
       inline: spec.mode === 'inlineSpread',
       properties: Object.entries(spec.children)
-        .filter(([, child]) => child !== undefined)
+        .filter(([, child]) => child != null)
         .map(([childName, child]) =>
           ast.createFunctionParameter({
             name:
@@ -92,8 +92,8 @@ function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNo
  * 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 | undefined>) {
-  const entries = Object.entries(params).filter(([, spec]) => spec !== undefined) as Array<[string, ParamSpec]>
+export function createFunctionParams(params: Record<string, ParamSpec | null | undefined>) {
+  const entries = Object.entries(params).filter(([, spec]) => spec != null) as Array<[string, ParamSpec]>
 
   return {
     toConstructor() {